// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/shared/k8s/metadatapb/metadata.proto

package metadatapb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
	typespb "px.dev/pixie/src/shared/types/typespb"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type DNSPolicy int32

const (
	DEFAULT                     DNSPolicy = 0
	NONE                        DNSPolicy = 1
	CLUSTER_FIRST               DNSPolicy = 2
	CLUSTER_FIRST_WITH_HOST_NET DNSPolicy = 3
)

var DNSPolicy_name = map[int32]string{
	0: "DEFAULT",
	1: "NONE",
	2: "CLUSTER_FIRST",
	3: "CLUSTER_FIRST_WITH_HOST_NET",
}

var DNSPolicy_value = map[string]int32{
	"DEFAULT":                     0,
	"NONE":                        1,
	"CLUSTER_FIRST":               2,
	"CLUSTER_FIRST_WITH_HOST_NET": 3,
}

func (DNSPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{0}
}

type PodPhase int32

const (
	PHASE_UNKNOWN PodPhase = 0
	PENDING       PodPhase = 1
	RUNNING       PodPhase = 2
	SUCCEEDED     PodPhase = 3
	FAILED        PodPhase = 4
	TERMINATED    PodPhase = 5
)

var PodPhase_name = map[int32]string{
	0: "PHASE_UNKNOWN",
	1: "PENDING",
	2: "RUNNING",
	3: "SUCCEEDED",
	4: "FAILED",
	5: "TERMINATED",
}

var PodPhase_value = map[string]int32{
	"PHASE_UNKNOWN": 0,
	"PENDING":       1,
	"RUNNING":       2,
	"SUCCEEDED":     3,
	"FAILED":        4,
	"TERMINATED":    5,
}

func (PodPhase) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{1}
}

type PodQOSClass int32

const (
	QOS_CLASS_UNKNOWN     PodQOSClass = 0
	QOS_CLASS_GUARANTEED  PodQOSClass = 1
	QOS_CLASS_BURSTABLE   PodQOSClass = 2
	QOS_CLASS_BEST_EFFORT PodQOSClass = 3
)

var PodQOSClass_name = map[int32]string{
	0: "QOS_CLASS_UNKNOWN",
	1: "QOS_CLASS_GUARANTEED",
	2: "QOS_CLASS_BURSTABLE",
	3: "QOS_CLASS_BEST_EFFORT",
}

var PodQOSClass_value = map[string]int32{
	"QOS_CLASS_UNKNOWN":     0,
	"QOS_CLASS_GUARANTEED":  1,
	"QOS_CLASS_BURSTABLE":   2,
	"QOS_CLASS_BEST_EFFORT": 3,
}

func (PodQOSClass) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{2}
}

type ContainerState int32

const (
	CONTAINER_STATE_UNKNOWN    ContainerState = 0
	CONTAINER_STATE_RUNNING    ContainerState = 1
	CONTAINER_STATE_TERMINATED ContainerState = 2
	CONTAINER_STATE_WAITING    ContainerState = 3
)

var ContainerState_name = map[int32]string{
	0: "CONTAINER_STATE_UNKNOWN",
	1: "CONTAINER_STATE_RUNNING",
	2: "CONTAINER_STATE_TERMINATED",
	3: "CONTAINER_STATE_WAITING",
}

var ContainerState_value = map[string]int32{
	"CONTAINER_STATE_UNKNOWN":    0,
	"CONTAINER_STATE_RUNNING":    1,
	"CONTAINER_STATE_TERMINATED": 2,
	"CONTAINER_STATE_WAITING":    3,
}

func (ContainerState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{3}
}

type PodConditionType int32

const (
	TYPE_UNKNOWN     PodConditionType = 0
	POD_SCHEDULED    PodConditionType = 1
	READY            PodConditionType = 2
	INITIALIZED      PodConditionType = 3
	UNSCHEDULABLE    PodConditionType = 4
	CONTAINERS_READY PodConditionType = 5
)

var PodConditionType_name = map[int32]string{
	0: "TYPE_UNKNOWN",
	1: "POD_SCHEDULED",
	2: "READY",
	3: "INITIALIZED",
	4: "UNSCHEDULABLE",
	5: "CONTAINERS_READY",
}

var PodConditionType_value = map[string]int32{
	"TYPE_UNKNOWN":     0,
	"POD_SCHEDULED":    1,
	"READY":            2,
	"INITIALIZED":      3,
	"UNSCHEDULABLE":    4,
	"CONTAINERS_READY": 5,
}

func (PodConditionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{4}
}

type IPProtocol int32

const (
	IP_PROTOCOL_UNKNOWN IPProtocol = 0
	TCP                 IPProtocol = 1
	UDP                 IPProtocol = 2
	SCTP                IPProtocol = 3
)

var IPProtocol_name = map[int32]string{
	0: "IP_PROTOCOL_UNKNOWN",
	1: "TCP",
	2: "UDP",
	3: "SCTP",
}

var IPProtocol_value = map[string]int32{
	"IP_PROTOCOL_UNKNOWN": 0,
	"TCP":                 1,
	"UDP":                 2,
	"SCTP":                3,
}

func (IPProtocol) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{5}
}

type ServiceType int32

const (
	SERVICE_TYPE_UNKNOWN ServiceType = 0
	EXTERNAL_NAME        ServiceType = 1
	CLUSTER_IP           ServiceType = 2
	NODE_PORT            ServiceType = 3
	LOAD_BALANCER        ServiceType = 4
)

var ServiceType_name = map[int32]string{
	0: "SERVICE_TYPE_UNKNOWN",
	1: "EXTERNAL_NAME",
	2: "CLUSTER_IP",
	3: "NODE_PORT",
	4: "LOAD_BALANCER",
}

var ServiceType_value = map[string]int32{
	"SERVICE_TYPE_UNKNOWN": 0,
	"EXTERNAL_NAME":        1,
	"CLUSTER_IP":           2,
	"NODE_PORT":            3,
	"LOAD_BALANCER":        4,
}

func (ServiceType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{6}
}

type ExternalTrafficPolicyType int32

const (
	TRAFFIC_POLICY_TYPE_UNKNOWN ExternalTrafficPolicyType = 0
	TRAFFIC_LOCAL               ExternalTrafficPolicyType = 1
	TRAFFIC_CLUSTER             ExternalTrafficPolicyType = 2
)

var ExternalTrafficPolicyType_name = map[int32]string{
	0: "TRAFFIC_POLICY_TYPE_UNKNOWN",
	1: "TRAFFIC_LOCAL",
	2: "TRAFFIC_CLUSTER",
}

var ExternalTrafficPolicyType_value = map[string]int32{
	"TRAFFIC_POLICY_TYPE_UNKNOWN": 0,
	"TRAFFIC_LOCAL":               1,
	"TRAFFIC_CLUSTER":             2,
}

func (ExternalTrafficPolicyType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{7}
}

type ContainerType int32

const (
	CONTAINER_TYPE_UNKNOWN    ContainerType = 0
	CONTAINER_TYPE_DOCKER     ContainerType = 1
	CONTAINER_TYPE_CRIO       ContainerType = 2
	CONTAINER_TYPE_CONTAINERD ContainerType = 3
)

var ContainerType_name = map[int32]string{
	0: "CONTAINER_TYPE_UNKNOWN",
	1: "CONTAINER_TYPE_DOCKER",
	2: "CONTAINER_TYPE_CRIO",
	3: "CONTAINER_TYPE_CONTAINERD",
}

var ContainerType_value = map[string]int32{
	"CONTAINER_TYPE_UNKNOWN":    0,
	"CONTAINER_TYPE_DOCKER":     1,
	"CONTAINER_TYPE_CRIO":       2,
	"CONTAINER_TYPE_CONTAINERD": 3,
}

func (ContainerType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{8}
}

type NodePhase int32

const (
	NODE_PHASE_UNKNOWN    NodePhase = 0
	NODE_PHASE_PENDING    NodePhase = 1
	NODE_PHASE_RUNNING    NodePhase = 2
	NODE_PHASE_TERMINATED NodePhase = 3
)

var NodePhase_name = map[int32]string{
	0: "NODE_PHASE_UNKNOWN",
	1: "NODE_PHASE_PENDING",
	2: "NODE_PHASE_RUNNING",
	3: "NODE_PHASE_TERMINATED",
}

var NodePhase_value = map[string]int32{
	"NODE_PHASE_UNKNOWN":    0,
	"NODE_PHASE_PENDING":    1,
	"NODE_PHASE_RUNNING":    2,
	"NODE_PHASE_TERMINATED": 3,
}

func (NodePhase) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{9}
}

type NodeAddressType int32

const (
	NODE_ADDR_TYPE_UNKNOWN      NodeAddressType = 0
	NODE_ADDR_TYPE_HOSTNAME     NodeAddressType = 1
	NODE_ADDR_TYPE_EXTERNAL_IP  NodeAddressType = 2
	NODE_ADDR_TYPE_INTERNAL_IP  NodeAddressType = 3
	NODE_ADDR_TYPE_EXTERNAL_DNS NodeAddressType = 4
	NODE_ADDR_TYPE_INTERNAL_DNS NodeAddressType = 5
)

var NodeAddressType_name = map[int32]string{
	0: "NODE_ADDR_TYPE_UNKNOWN",
	1: "NODE_ADDR_TYPE_HOSTNAME",
	2: "NODE_ADDR_TYPE_EXTERNAL_IP",
	3: "NODE_ADDR_TYPE_INTERNAL_IP",
	4: "NODE_ADDR_TYPE_EXTERNAL_DNS",
	5: "NODE_ADDR_TYPE_INTERNAL_DNS",
}

var NodeAddressType_value = map[string]int32{
	"NODE_ADDR_TYPE_UNKNOWN":      0,
	"NODE_ADDR_TYPE_HOSTNAME":     1,
	"NODE_ADDR_TYPE_EXTERNAL_IP":  2,
	"NODE_ADDR_TYPE_INTERNAL_IP":  3,
	"NODE_ADDR_TYPE_EXTERNAL_DNS": 4,
	"NODE_ADDR_TYPE_INTERNAL_DNS": 5,
}

func (NodeAddressType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{10}
}

type ConditionStatus int32

const (
	CONDITION_STATUS_UNKNOWN ConditionStatus = 0
	CONDITION_STATUS_TRUE    ConditionStatus = 1
	CONDITION_STATUS_FALSE   ConditionStatus = 2
)

var ConditionStatus_name = map[int32]string{
	0: "CONDITION_STATUS_UNKNOWN",
	1: "CONDITION_STATUS_TRUE",
	2: "CONDITION_STATUS_FALSE",
}

var ConditionStatus_value = map[string]int32{
	"CONDITION_STATUS_UNKNOWN": 0,
	"CONDITION_STATUS_TRUE":    1,
	"CONDITION_STATUS_FALSE":   2,
}

func (ConditionStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{11}
}

type NodeConditionType int32

const (
	NODE_CONDITION_UNKNOWN             NodeConditionType = 0
	NODE_CONDITION_READY               NodeConditionType = 1
	NODE_CONDITION_MEMORY_PRESSURE     NodeConditionType = 2
	NODE_CONDITION_DISK_PRESSURE       NodeConditionType = 3
	NODE_CONDITION_PID_PRESSURE        NodeConditionType = 4
	NODE_CONDITION_NETWORK_UNAVAILABLE NodeConditionType = 5
)

var NodeConditionType_name = map[int32]string{
	0: "NODE_CONDITION_UNKNOWN",
	1: "NODE_CONDITION_READY",
	2: "NODE_CONDITION_MEMORY_PRESSURE",
	3: "NODE_CONDITION_DISK_PRESSURE",
	4: "NODE_CONDITION_PID_PRESSURE",
	5: "NODE_CONDITION_NETWORK_UNAVAILABLE",
}

var NodeConditionType_value = map[string]int32{
	"NODE_CONDITION_UNKNOWN":             0,
	"NODE_CONDITION_READY":               1,
	"NODE_CONDITION_MEMORY_PRESSURE":     2,
	"NODE_CONDITION_DISK_PRESSURE":       3,
	"NODE_CONDITION_PID_PRESSURE":        4,
	"NODE_CONDITION_NETWORK_UNAVAILABLE": 5,
}

func (NodeConditionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{12}
}

type DeploymentConditionType int32

const (
	DEPLOYMENT_CONDITION_TYPE_UNKNOWN    DeploymentConditionType = 0
	DEPLOYMENT_CONDITION_AVAILABLE       DeploymentConditionType = 1
	DEPLOYMENT_CONDITION_PROGRESSING     DeploymentConditionType = 2
	DEPLOYMENT_CONDITION_REPLICA_FAILURE DeploymentConditionType = 3
)

var DeploymentConditionType_name = map[int32]string{
	0: "DEPLOYMENT_CONDITION_TYPE_UNKNOWN",
	1: "DEPLOYMENT_CONDITION_AVAILABLE",
	2: "DEPLOYMENT_CONDITION_PROGRESSING",
	3: "DEPLOYMENT_CONDITION_REPLICA_FAILURE",
}

var DeploymentConditionType_value = map[string]int32{
	"DEPLOYMENT_CONDITION_TYPE_UNKNOWN":    0,
	"DEPLOYMENT_CONDITION_AVAILABLE":       1,
	"DEPLOYMENT_CONDITION_PROGRESSING":     2,
	"DEPLOYMENT_CONDITION_REPLICA_FAILURE": 3,
}

func (DeploymentConditionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{13}
}

type DeploymentStrategyType int32

const (
	DEPLOYMENT_STRATEGY_UNKNOWN        DeploymentStrategyType = 0
	DEPLOYMENT_STRATEGY_RECREATE       DeploymentStrategyType = 1
	DEPLOYMENT_STRATEGY_ROLLING_UPDATE DeploymentStrategyType = 2
)

var DeploymentStrategyType_name = map[int32]string{
	0: "DEPLOYMENT_STRATEGY_UNKNOWN",
	1: "DEPLOYMENT_STRATEGY_RECREATE",
	2: "DEPLOYMENT_STRATEGY_ROLLING_UPDATE",
}

var DeploymentStrategyType_value = map[string]int32{
	"DEPLOYMENT_STRATEGY_UNKNOWN":        0,
	"DEPLOYMENT_STRATEGY_RECREATE":       1,
	"DEPLOYMENT_STRATEGY_ROLLING_UPDATE": 2,
}

func (DeploymentStrategyType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{14}
}

type MetadataObject struct {
	// Types that are valid to be assigned to Object:
	//	*MetadataObject_Pod
	//	*MetadataObject_Endpoints
	//	*MetadataObject_Service
	//	*MetadataObject_Namespace
	//	*MetadataObject_Node
	//	*MetadataObject_ReplicaSet
	Object isMetadataObject_Object `protobuf_oneof:"object"`
}

func (m *MetadataObject) Reset()      { *m = MetadataObject{} }
func (*MetadataObject) ProtoMessage() {}
func (*MetadataObject) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{0}
}
func (m *MetadataObject) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetadataObject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MetadataObject.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MetadataObject) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetadataObject.Merge(m, src)
}
func (m *MetadataObject) XXX_Size() int {
	return m.Size()
}
func (m *MetadataObject) XXX_DiscardUnknown() {
	xxx_messageInfo_MetadataObject.DiscardUnknown(m)
}

var xxx_messageInfo_MetadataObject proto.InternalMessageInfo

type isMetadataObject_Object interface {
	isMetadataObject_Object()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type MetadataObject_Pod struct {
	Pod *Pod `protobuf:"bytes,1,opt,name=pod,proto3,oneof" json:"pod,omitempty"`
}
type MetadataObject_Endpoints struct {
	Endpoints *Endpoints `protobuf:"bytes,2,opt,name=endpoints,proto3,oneof" json:"endpoints,omitempty"`
}
type MetadataObject_Service struct {
	Service *Service `protobuf:"bytes,3,opt,name=service,proto3,oneof" json:"service,omitempty"`
}
type MetadataObject_Namespace struct {
	Namespace *Namespace `protobuf:"bytes,4,opt,name=namespace,proto3,oneof" json:"namespace,omitempty"`
}
type MetadataObject_Node struct {
	Node *Node `protobuf:"bytes,5,opt,name=node,proto3,oneof" json:"node,omitempty"`
}
type MetadataObject_ReplicaSet struct {
	ReplicaSet *ReplicaSet `protobuf:"bytes,6,opt,name=replicaSet,proto3,oneof" json:"replicaSet,omitempty"`
}

func (*MetadataObject_Pod) isMetadataObject_Object()        {}
func (*MetadataObject_Endpoints) isMetadataObject_Object()  {}
func (*MetadataObject_Service) isMetadataObject_Object()    {}
func (*MetadataObject_Namespace) isMetadataObject_Object()  {}
func (*MetadataObject_Node) isMetadataObject_Object()       {}
func (*MetadataObject_ReplicaSet) isMetadataObject_Object() {}

func (m *MetadataObject) GetObject() isMetadataObject_Object {
	if m != nil {
		return m.Object
	}
	return nil
}

func (m *MetadataObject) GetPod() *Pod {
	if x, ok := m.GetObject().(*MetadataObject_Pod); ok {
		return x.Pod
	}
	return nil
}

func (m *MetadataObject) GetEndpoints() *Endpoints {
	if x, ok := m.GetObject().(*MetadataObject_Endpoints); ok {
		return x.Endpoints
	}
	return nil
}

func (m *MetadataObject) GetService() *Service {
	if x, ok := m.GetObject().(*MetadataObject_Service); ok {
		return x.Service
	}
	return nil
}

func (m *MetadataObject) GetNamespace() *Namespace {
	if x, ok := m.GetObject().(*MetadataObject_Namespace); ok {
		return x.Namespace
	}
	return nil
}

func (m *MetadataObject) GetNode() *Node {
	if x, ok := m.GetObject().(*MetadataObject_Node); ok {
		return x.Node
	}
	return nil
}

func (m *MetadataObject) GetReplicaSet() *ReplicaSet {
	if x, ok := m.GetObject().(*MetadataObject_ReplicaSet); ok {
		return x.ReplicaSet
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MetadataObject) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MetadataObject_Pod)(nil),
		(*MetadataObject_Endpoints)(nil),
		(*MetadataObject_Service)(nil),
		(*MetadataObject_Namespace)(nil),
		(*MetadataObject_Node)(nil),
		(*MetadataObject_ReplicaSet)(nil),
	}
}

type ObjectMetadata struct {
	Name                string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Namespace           string            `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	UID                 string            `protobuf:"bytes,3,opt,name=uid,proto3" json:"uid,omitempty"`
	ResourceVersion     string            `protobuf:"bytes,4,opt,name=resource_version,json=resourceVersion,proto3" json:"resource_version,omitempty"`
	CreationTimestampNS int64             `protobuf:"varint,5,opt,name=creation_timestamp_ns,json=creationTimestampNs,proto3" json:"creation_timestamp_ns,omitempty"`
	DeletionTimestampNS int64             `protobuf:"varint,6,opt,name=deletion_timestamp_ns,json=deletionTimestampNs,proto3" json:"deletion_timestamp_ns,omitempty"`
	Labels              map[string]string `protobuf:"bytes,7,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	OwnerReferences     []*OwnerReference `protobuf:"bytes,8,rep,name=owner_references,json=ownerReferences,proto3" json:"owner_references,omitempty"`
	Annotations         map[string]string `protobuf:"bytes,10,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *ObjectMetadata) Reset()      { *m = ObjectMetadata{} }
func (*ObjectMetadata) ProtoMessage() {}
func (*ObjectMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{1}
}
func (m *ObjectMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ObjectMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ObjectMetadata.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ObjectMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ObjectMetadata.Merge(m, src)
}
func (m *ObjectMetadata) XXX_Size() int {
	return m.Size()
}
func (m *ObjectMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_ObjectMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_ObjectMetadata proto.InternalMessageInfo

func (m *ObjectMetadata) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ObjectMetadata) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ObjectMetadata) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *ObjectMetadata) GetResourceVersion() string {
	if m != nil {
		return m.ResourceVersion
	}
	return ""
}

func (m *ObjectMetadata) GetCreationTimestampNS() int64 {
	if m != nil {
		return m.CreationTimestampNS
	}
	return 0
}

func (m *ObjectMetadata) GetDeletionTimestampNS() int64 {
	if m != nil {
		return m.DeletionTimestampNS
	}
	return 0
}

func (m *ObjectMetadata) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *ObjectMetadata) GetOwnerReferences() []*OwnerReference {
	if m != nil {
		return m.OwnerReferences
	}
	return nil
}

func (m *ObjectMetadata) GetAnnotations() map[string]string {
	if m != nil {
		return m.Annotations
	}
	return nil
}

type OwnerReference struct {
	Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
	Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	UID  string `protobuf:"bytes,4,opt,name=uid,proto3" json:"uid,omitempty"`
}

func (m *OwnerReference) Reset()      { *m = OwnerReference{} }
func (*OwnerReference) ProtoMessage() {}
func (*OwnerReference) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{2}
}
func (m *OwnerReference) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OwnerReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OwnerReference.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OwnerReference) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OwnerReference.Merge(m, src)
}
func (m *OwnerReference) XXX_Size() int {
	return m.Size()
}
func (m *OwnerReference) XXX_DiscardUnknown() {
	xxx_messageInfo_OwnerReference.DiscardUnknown(m)
}

var xxx_messageInfo_OwnerReference proto.InternalMessageInfo

func (m *OwnerReference) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *OwnerReference) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *OwnerReference) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

type Namespace struct {
	Metadata *ObjectMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
}

func (m *Namespace) Reset()      { *m = Namespace{} }
func (*Namespace) ProtoMessage() {}
func (*Namespace) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{3}
}
func (m *Namespace) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Namespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Namespace.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Namespace) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Namespace.Merge(m, src)
}
func (m *Namespace) XXX_Size() int {
	return m.Size()
}
func (m *Namespace) XXX_DiscardUnknown() {
	xxx_messageInfo_Namespace.DiscardUnknown(m)
}

var xxx_messageInfo_Namespace proto.InternalMessageInfo

func (m *Namespace) GetMetadata() *ObjectMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

type Pod struct {
	Metadata *ObjectMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Spec     *PodSpec        `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	Status   *PodStatus      `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *Pod) Reset()      { *m = Pod{} }
func (*Pod) ProtoMessage() {}
func (*Pod) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{4}
}
func (m *Pod) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Pod) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Pod.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Pod) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Pod.Merge(m, src)
}
func (m *Pod) XXX_Size() int {
	return m.Size()
}
func (m *Pod) XXX_DiscardUnknown() {
	xxx_messageInfo_Pod.DiscardUnknown(m)
}

var xxx_messageInfo_Pod proto.InternalMessageInfo

func (m *Pod) GetMetadata() *ObjectMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Pod) GetSpec() *PodSpec {
	if m != nil {
		return m.Spec
	}
	return nil
}

func (m *Pod) GetStatus() *PodStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type PodSpec struct {
	DNSPolicy         DNSPolicy         `protobuf:"varint,1,opt,name=dns_policy,json=dnsPolicy,proto3,enum=px.shared.k8s.metadatapb.DNSPolicy" json:"dns_policy,omitempty"`
	NodeSelector      map[string]string `protobuf:"bytes,2,rep,name=node_selector,json=nodeSelector,proto3" json:"node_selector,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	NodeName          string            `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	Hostname          string            `protobuf:"bytes,4,opt,name=hostname,proto3" json:"hostname,omitempty"`
	Subdomain         string            `protobuf:"bytes,5,opt,name=subdomain,proto3" json:"subdomain,omitempty"`
	PriorityClassName string            `protobuf:"bytes,6,opt,name=priority_class_name,json=priorityClassName,proto3" json:"priority_class_name,omitempty"`
	Priority          int32             `protobuf:"varint,7,opt,name=priority,proto3" json:"priority,omitempty"`
}

func (m *PodSpec) Reset()      { *m = PodSpec{} }
func (*PodSpec) ProtoMessage() {}
func (*PodSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{5}
}
func (m *PodSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PodSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PodSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PodSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodSpec.Merge(m, src)
}
func (m *PodSpec) XXX_Size() int {
	return m.Size()
}
func (m *PodSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_PodSpec.DiscardUnknown(m)
}

var xxx_messageInfo_PodSpec proto.InternalMessageInfo

func (m *PodSpec) GetDNSPolicy() DNSPolicy {
	if m != nil {
		return m.DNSPolicy
	}
	return DEFAULT
}

func (m *PodSpec) GetNodeSelector() map[string]string {
	if m != nil {
		return m.NodeSelector
	}
	return nil
}

func (m *PodSpec) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *PodSpec) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *PodSpec) GetSubdomain() string {
	if m != nil {
		return m.Subdomain
	}
	return ""
}

func (m *PodSpec) GetPriorityClassName() string {
	if m != nil {
		return m.PriorityClassName
	}
	return ""
}

func (m *PodSpec) GetPriority() int32 {
	if m != nil {
		return m.Priority
	}
	return 0
}

type ContainerStatus struct {
	Name             string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ContainerID      string         `protobuf:"bytes,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
	ContainerState   ContainerState `protobuf:"varint,3,opt,name=container_state,json=containerState,proto3,enum=px.shared.k8s.metadatapb.ContainerState" json:"container_state,omitempty"`
	StartTimestampNS int64          `protobuf:"varint,4,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS  int64          `protobuf:"varint,5,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
	Message          string         `protobuf:"bytes,6,opt,name=message,proto3" json:"message,omitempty"`
	Reason           string         `protobuf:"bytes,7,opt,name=reason,proto3" json:"reason,omitempty"`
	RestartCount     int64          `protobuf:"varint,8,opt,name=restart_count,json=restartCount,proto3" json:"restart_count,omitempty"`
}

func (m *ContainerStatus) Reset()      { *m = ContainerStatus{} }
func (*ContainerStatus) ProtoMessage() {}
func (*ContainerStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{6}
}
func (m *ContainerStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ContainerStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ContainerStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ContainerStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerStatus.Merge(m, src)
}
func (m *ContainerStatus) XXX_Size() int {
	return m.Size()
}
func (m *ContainerStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerStatus proto.InternalMessageInfo

func (m *ContainerStatus) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ContainerStatus) GetContainerID() string {
	if m != nil {
		return m.ContainerID
	}
	return ""
}

func (m *ContainerStatus) GetContainerState() ContainerState {
	if m != nil {
		return m.ContainerState
	}
	return CONTAINER_STATE_UNKNOWN
}

func (m *ContainerStatus) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *ContainerStatus) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

func (m *ContainerStatus) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *ContainerStatus) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *ContainerStatus) GetRestartCount() int64 {
	if m != nil {
		return m.RestartCount
	}
	return 0
}

type K8SEvent struct {
	Message   string           `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	FirstTime *types.Timestamp `protobuf:"bytes,2,opt,name=first_time,json=firstTime,proto3" json:"first_time,omitempty"`
	LastTime  *types.Timestamp `protobuf:"bytes,3,opt,name=last_time,json=lastTime,proto3" json:"last_time,omitempty"`
}

func (m *K8SEvent) Reset()      { *m = K8SEvent{} }
func (*K8SEvent) ProtoMessage() {}
func (*K8SEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{7}
}
func (m *K8SEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *K8SEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_K8SEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *K8SEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_K8SEvent.Merge(m, src)
}
func (m *K8SEvent) XXX_Size() int {
	return m.Size()
}
func (m *K8SEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_K8SEvent.DiscardUnknown(m)
}

var xxx_messageInfo_K8SEvent proto.InternalMessageInfo

func (m *K8SEvent) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *K8SEvent) GetFirstTime() *types.Timestamp {
	if m != nil {
		return m.FirstTime
	}
	return nil
}

func (m *K8SEvent) GetLastTime() *types.Timestamp {
	if m != nil {
		return m.LastTime
	}
	return nil
}

type PodStatus struct {
	Phase             PodPhase           `protobuf:"varint,1,opt,name=phase,proto3,enum=px.shared.k8s.metadatapb.PodPhase" json:"phase,omitempty"`
	Conditions        []*PodCondition    `protobuf:"bytes,9,rep,name=conditions,proto3" json:"conditions,omitempty"`
	Message           string             `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Reason            string             `protobuf:"bytes,4,opt,name=reason,proto3" json:"reason,omitempty"`
	HostIP            string             `protobuf:"bytes,5,opt,name=host_ip,json=hostIp,proto3" json:"host_ip,omitempty"`
	PodIP             string             `protobuf:"bytes,6,opt,name=pod_ip,json=podIp,proto3" json:"pod_ip,omitempty"`
	QOSClass          PodQOSClass        `protobuf:"varint,7,opt,name=qos_class,json=qosClass,proto3,enum=px.shared.k8s.metadatapb.PodQOSClass" json:"qos_class,omitempty"`
	ContainerStatuses []*ContainerStatus `protobuf:"bytes,8,rep,name=container_statuses,json=containerStatuses,proto3" json:"container_statuses,omitempty"`
	CreatedAt         *types.Timestamp   `protobuf:"bytes,11,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	Events            []*K8SEvent        `protobuf:"bytes,12,rep,name=events,proto3" json:"events,omitempty"`
	RestartCount      int64              `protobuf:"varint,13,opt,name=restart_count,json=restartCount,proto3" json:"restart_count,omitempty"`
}

func (m *PodStatus) Reset()      { *m = PodStatus{} }
func (*PodStatus) ProtoMessage() {}
func (*PodStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{8}
}
func (m *PodStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PodStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PodStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PodStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodStatus.Merge(m, src)
}
func (m *PodStatus) XXX_Size() int {
	return m.Size()
}
func (m *PodStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_PodStatus.DiscardUnknown(m)
}

var xxx_messageInfo_PodStatus proto.InternalMessageInfo

func (m *PodStatus) GetPhase() PodPhase {
	if m != nil {
		return m.Phase
	}
	return PHASE_UNKNOWN
}

func (m *PodStatus) GetConditions() []*PodCondition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

func (m *PodStatus) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *PodStatus) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *PodStatus) GetHostIP() string {
	if m != nil {
		return m.HostIP
	}
	return ""
}

func (m *PodStatus) GetPodIP() string {
	if m != nil {
		return m.PodIP
	}
	return ""
}

func (m *PodStatus) GetQOSClass() PodQOSClass {
	if m != nil {
		return m.QOSClass
	}
	return QOS_CLASS_UNKNOWN
}

func (m *PodStatus) GetContainerStatuses() []*ContainerStatus {
	if m != nil {
		return m.ContainerStatuses
	}
	return nil
}

func (m *PodStatus) GetCreatedAt() *types.Timestamp {
	if m != nil {
		return m.CreatedAt
	}
	return nil
}

func (m *PodStatus) GetEvents() []*K8SEvent {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *PodStatus) GetRestartCount() int64 {
	if m != nil {
		return m.RestartCount
	}
	return 0
}

type PodCondition struct {
	Type   PodConditionType `protobuf:"varint,1,opt,name=type,proto3,enum=px.shared.k8s.metadatapb.PodConditionType" json:"type,omitempty"`
	Status ConditionStatus  `protobuf:"varint,2,opt,name=status,proto3,enum=px.shared.k8s.metadatapb.ConditionStatus" json:"status,omitempty"`
}

func (m *PodCondition) Reset()      { *m = PodCondition{} }
func (*PodCondition) ProtoMessage() {}
func (*PodCondition) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{9}
}
func (m *PodCondition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PodCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PodCondition.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PodCondition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodCondition.Merge(m, src)
}
func (m *PodCondition) XXX_Size() int {
	return m.Size()
}
func (m *PodCondition) XXX_DiscardUnknown() {
	xxx_messageInfo_PodCondition.DiscardUnknown(m)
}

var xxx_messageInfo_PodCondition proto.InternalMessageInfo

func (m *PodCondition) GetType() PodConditionType {
	if m != nil {
		return m.Type
	}
	return TYPE_UNKNOWN
}

func (m *PodCondition) GetStatus() ConditionStatus {
	if m != nil {
		return m.Status
	}
	return CONDITION_STATUS_UNKNOWN
}

type Endpoints struct {
	Metadata *ObjectMetadata   `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Subsets  []*EndpointSubset `protobuf:"bytes,2,rep,name=subsets,proto3" json:"subsets,omitempty"`
}

func (m *Endpoints) Reset()      { *m = Endpoints{} }
func (*Endpoints) ProtoMessage() {}
func (*Endpoints) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{10}
}
func (m *Endpoints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Endpoints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Endpoints.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Endpoints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Endpoints.Merge(m, src)
}
func (m *Endpoints) XXX_Size() int {
	return m.Size()
}
func (m *Endpoints) XXX_DiscardUnknown() {
	xxx_messageInfo_Endpoints.DiscardUnknown(m)
}

var xxx_messageInfo_Endpoints proto.InternalMessageInfo

func (m *Endpoints) GetMetadata() *ObjectMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Endpoints) GetSubsets() []*EndpointSubset {
	if m != nil {
		return m.Subsets
	}
	return nil
}

type EndpointSubset struct {
	Addresses         []*EndpointAddress `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
	NotReadyAddresses []*EndpointAddress `protobuf:"bytes,2,rep,name=not_ready_addresses,json=notReadyAddresses,proto3" json:"not_ready_addresses,omitempty"`
	Ports             []*EndpointPort    `protobuf:"bytes,3,rep,name=ports,proto3" json:"ports,omitempty"`
}

func (m *EndpointSubset) Reset()      { *m = EndpointSubset{} }
func (*EndpointSubset) ProtoMessage() {}
func (*EndpointSubset) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{11}
}
func (m *EndpointSubset) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EndpointSubset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EndpointSubset.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EndpointSubset) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EndpointSubset.Merge(m, src)
}
func (m *EndpointSubset) XXX_Size() int {
	return m.Size()
}
func (m *EndpointSubset) XXX_DiscardUnknown() {
	xxx_messageInfo_EndpointSubset.DiscardUnknown(m)
}

var xxx_messageInfo_EndpointSubset proto.InternalMessageInfo

func (m *EndpointSubset) GetAddresses() []*EndpointAddress {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *EndpointSubset) GetNotReadyAddresses() []*EndpointAddress {
	if m != nil {
		return m.NotReadyAddresses
	}
	return nil
}

func (m *EndpointSubset) GetPorts() []*EndpointPort {
	if m != nil {
		return m.Ports
	}
	return nil
}

type EndpointAddress struct {
	IP        string           `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
	Hostname  string           `protobuf:"bytes,2,opt,name=hostname,proto3" json:"hostname,omitempty"`
	NodeName  string           `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	TargetRef *ObjectReference `protobuf:"bytes,4,opt,name=target_ref,json=targetRef,proto3" json:"target_ref,omitempty"`
}

func (m *EndpointAddress) Reset()      { *m = EndpointAddress{} }
func (*EndpointAddress) ProtoMessage() {}
func (*EndpointAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{12}
}
func (m *EndpointAddress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EndpointAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EndpointAddress.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EndpointAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EndpointAddress.Merge(m, src)
}
func (m *EndpointAddress) XXX_Size() int {
	return m.Size()
}
func (m *EndpointAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_EndpointAddress.DiscardUnknown(m)
}

var xxx_messageInfo_EndpointAddress proto.InternalMessageInfo

func (m *EndpointAddress) GetIP() string {
	if m != nil {
		return m.IP
	}
	return ""
}

func (m *EndpointAddress) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *EndpointAddress) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *EndpointAddress) GetTargetRef() *ObjectReference {
	if m != nil {
		return m.TargetRef
	}
	return nil
}

type EndpointPort struct {
	Name     string     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Port     int32      `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	Protocol IPProtocol `protobuf:"varint,3,opt,name=protocol,proto3,enum=px.shared.k8s.metadatapb.IPProtocol" json:"protocol,omitempty"`
}

func (m *EndpointPort) Reset()      { *m = EndpointPort{} }
func (*EndpointPort) ProtoMessage() {}
func (*EndpointPort) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{13}
}
func (m *EndpointPort) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EndpointPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EndpointPort.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EndpointPort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EndpointPort.Merge(m, src)
}
func (m *EndpointPort) XXX_Size() int {
	return m.Size()
}
func (m *EndpointPort) XXX_DiscardUnknown() {
	xxx_messageInfo_EndpointPort.DiscardUnknown(m)
}

var xxx_messageInfo_EndpointPort proto.InternalMessageInfo

func (m *EndpointPort) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *EndpointPort) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *EndpointPort) GetProtocol() IPProtocol {
	if m != nil {
		return m.Protocol
	}
	return IP_PROTOCOL_UNKNOWN
}

type ObjectReference struct {
	Kind            string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
	Namespace       string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Name            string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	UID             string `protobuf:"bytes,4,opt,name=uid,proto3" json:"uid,omitempty"`
	ResourceVersion string `protobuf:"bytes,6,opt,name=resourceVersion,proto3" json:"resourceVersion,omitempty"`
}

func (m *ObjectReference) Reset()      { *m = ObjectReference{} }
func (*ObjectReference) ProtoMessage() {}
func (*ObjectReference) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{14}
}
func (m *ObjectReference) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ObjectReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ObjectReference.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ObjectReference) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ObjectReference.Merge(m, src)
}
func (m *ObjectReference) XXX_Size() int {
	return m.Size()
}
func (m *ObjectReference) XXX_DiscardUnknown() {
	xxx_messageInfo_ObjectReference.DiscardUnknown(m)
}

var xxx_messageInfo_ObjectReference proto.InternalMessageInfo

func (m *ObjectReference) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *ObjectReference) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ObjectReference) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ObjectReference) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *ObjectReference) GetResourceVersion() string {
	if m != nil {
		return m.ResourceVersion
	}
	return ""
}

type Service struct {
	Metadata *ObjectMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Spec     *ServiceSpec    `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
}

func (m *Service) Reset()      { *m = Service{} }
func (*Service) ProtoMessage() {}
func (*Service) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{15}
}
func (m *Service) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Service) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Service.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Service) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Service.Merge(m, src)
}
func (m *Service) XXX_Size() int {
	return m.Size()
}
func (m *Service) XXX_DiscardUnknown() {
	xxx_messageInfo_Service.DiscardUnknown(m)
}

var xxx_messageInfo_Service proto.InternalMessageInfo

func (m *Service) GetMetadata() *ObjectMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Service) GetSpec() *ServiceSpec {
	if m != nil {
		return m.Spec
	}
	return nil
}

type ServiceSpec struct {
	Ports                 []*ServicePort            `protobuf:"bytes,1,rep,name=ports,proto3" json:"ports,omitempty"`
	ClusterIP             string                    `protobuf:"bytes,2,opt,name=cluster_ip,json=clusterIp,proto3" json:"cluster_ip,omitempty"`
	Type                  ServiceType               `protobuf:"varint,3,opt,name=type,proto3,enum=px.shared.k8s.metadatapb.ServiceType" json:"type,omitempty"`
	ExternalIPs           []string                  `protobuf:"bytes,4,rep,name=external_ips,json=externalIps,proto3" json:"external_ips,omitempty"`
	LoadBalancerIP        string                    `protobuf:"bytes,5,opt,name=load_balancer_ip,json=loadBalancerIp,proto3" json:"load_balancer_ip,omitempty"`
	ExternalName          string                    `protobuf:"bytes,6,opt,name=external_name,json=externalName,proto3" json:"external_name,omitempty"`
	ExternalTrafficPolicy ExternalTrafficPolicyType `protobuf:"varint,7,opt,name=external_traffic_policy,json=externalTrafficPolicy,proto3,enum=px.shared.k8s.metadatapb.ExternalTrafficPolicyType" json:"external_traffic_policy,omitempty"`
}

func (m *ServiceSpec) Reset()      { *m = ServiceSpec{} }
func (*ServiceSpec) ProtoMessage() {}
func (*ServiceSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{16}
}
func (m *ServiceSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ServiceSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ServiceSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ServiceSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceSpec.Merge(m, src)
}
func (m *ServiceSpec) XXX_Size() int {
	return m.Size()
}
func (m *ServiceSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceSpec proto.InternalMessageInfo

func (m *ServiceSpec) GetPorts() []*ServicePort {
	if m != nil {
		return m.Ports
	}
	return nil
}

func (m *ServiceSpec) GetClusterIP() string {
	if m != nil {
		return m.ClusterIP
	}
	return ""
}

func (m *ServiceSpec) GetType() ServiceType {
	if m != nil {
		return m.Type
	}
	return SERVICE_TYPE_UNKNOWN
}

func (m *ServiceSpec) GetExternalIPs() []string {
	if m != nil {
		return m.ExternalIPs
	}
	return nil
}

func (m *ServiceSpec) GetLoadBalancerIP() string {
	if m != nil {
		return m.LoadBalancerIP
	}
	return ""
}

func (m *ServiceSpec) GetExternalName() string {
	if m != nil {
		return m.ExternalName
	}
	return ""
}

func (m *ServiceSpec) GetExternalTrafficPolicy() ExternalTrafficPolicyType {
	if m != nil {
		return m.ExternalTrafficPolicy
	}
	return TRAFFIC_POLICY_TYPE_UNKNOWN
}

type ServicePort struct {
	Name     string     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Protocol IPProtocol `protobuf:"varint,2,opt,name=protocol,proto3,enum=px.shared.k8s.metadatapb.IPProtocol" json:"protocol,omitempty"`
	Port     int32      `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
	NodePort int32      `protobuf:"varint,4,opt,name=node_port,json=nodePort,proto3" json:"node_port,omitempty"`
}

func (m *ServicePort) Reset()      { *m = ServicePort{} }
func (*ServicePort) ProtoMessage() {}
func (*ServicePort) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{17}
}
func (m *ServicePort) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ServicePort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ServicePort.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ServicePort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServicePort.Merge(m, src)
}
func (m *ServicePort) XXX_Size() int {
	return m.Size()
}
func (m *ServicePort) XXX_DiscardUnknown() {
	xxx_messageInfo_ServicePort.DiscardUnknown(m)
}

var xxx_messageInfo_ServicePort proto.InternalMessageInfo

func (m *ServicePort) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ServicePort) GetProtocol() IPProtocol {
	if m != nil {
		return m.Protocol
	}
	return IP_PROTOCOL_UNKNOWN
}

func (m *ServicePort) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *ServicePort) GetNodePort() int32 {
	if m != nil {
		return m.NodePort
	}
	return 0
}

type ContainerInfo struct {
	Name             string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	UID              string         `protobuf:"bytes,2,opt,name=uid,proto3" json:"uid,omitempty"`
	StartTimestampNS int64          `protobuf:"varint,3,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS  int64          `protobuf:"varint,4,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
	PodUID           string         `protobuf:"bytes,5,opt,name=pod_uid,json=podUid,proto3" json:"pod_uid,omitempty"`
	Namespace        string         `protobuf:"bytes,6,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Processes        []*ProcessInfo `protobuf:"bytes,7,rep,name=processes,proto3" json:"processes,omitempty"`
}

func (m *ContainerInfo) Reset()      { *m = ContainerInfo{} }
func (*ContainerInfo) ProtoMessage() {}
func (*ContainerInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{18}
}
func (m *ContainerInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ContainerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ContainerInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ContainerInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerInfo.Merge(m, src)
}
func (m *ContainerInfo) XXX_Size() int {
	return m.Size()
}
func (m *ContainerInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerInfo proto.InternalMessageInfo

func (m *ContainerInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ContainerInfo) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *ContainerInfo) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *ContainerInfo) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

func (m *ContainerInfo) GetPodUID() string {
	if m != nil {
		return m.PodUID
	}
	return ""
}

func (m *ContainerInfo) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ContainerInfo) GetProcesses() []*ProcessInfo {
	if m != nil {
		return m.Processes
	}
	return nil
}

type ProcessInfo struct {
	Name             string           `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	UPID             *typespb.UInt128 `protobuf:"bytes,2,opt,name=upid,proto3" json:"upid,omitempty"`
	StartTimestampNS int64            `protobuf:"varint,4,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS  int64            `protobuf:"varint,5,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
	ProcessArgs      string           `protobuf:"bytes,6,opt,name=process_args,json=processArgs,proto3" json:"process_args,omitempty"`
	CID              string           `protobuf:"bytes,7,opt,name=cid,proto3" json:"cid,omitempty"`
}

func (m *ProcessInfo) Reset()      { *m = ProcessInfo{} }
func (*ProcessInfo) ProtoMessage() {}
func (*ProcessInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{19}
}
func (m *ProcessInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProcessInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProcessInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ProcessInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProcessInfo.Merge(m, src)
}
func (m *ProcessInfo) XXX_Size() int {
	return m.Size()
}
func (m *ProcessInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ProcessInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ProcessInfo proto.InternalMessageInfo

func (m *ProcessInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ProcessInfo) GetUPID() *typespb.UInt128 {
	if m != nil {
		return m.UPID
	}
	return nil
}

func (m *ProcessInfo) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *ProcessInfo) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

func (m *ProcessInfo) GetProcessArgs() string {
	if m != nil {
		return m.ProcessArgs
	}
	return ""
}

func (m *ProcessInfo) GetCID() string {
	if m != nil {
		return m.CID
	}
	return ""
}

type PodUpdate struct {
	UID              string            `protobuf:"bytes,1,opt,name=uid,proto3" json:"uid,omitempty"`
	Name             string            `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Namespace        string            `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	StartTimestampNS int64             `protobuf:"varint,4,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS  int64             `protobuf:"varint,5,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
	ContainerIDs     []string          `protobuf:"bytes,6,rep,name=container_ids,json=containerIds,proto3" json:"container_ids,omitempty"`
	ContainerNames   []string          `protobuf:"bytes,11,rep,name=container_names,json=containerNames,proto3" json:"container_names,omitempty"`
	QOSClass         PodQOSClass       `protobuf:"varint,7,opt,name=qos_class,json=qosClass,proto3,enum=px.shared.k8s.metadatapb.PodQOSClass" json:"qos_class,omitempty"`
	Phase            PodPhase          `protobuf:"varint,8,opt,name=phase,proto3,enum=px.shared.k8s.metadatapb.PodPhase" json:"phase,omitempty"`
	Conditions       []*PodCondition   `protobuf:"bytes,16,rep,name=conditions,proto3" json:"conditions,omitempty"`
	NodeName         string            `protobuf:"bytes,9,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	Hostname         string            `protobuf:"bytes,10,opt,name=hostname,proto3" json:"hostname,omitempty"`
	PodIP            string            `protobuf:"bytes,12,opt,name=pod_ip,json=podIp,proto3" json:"pod_ip,omitempty"`
	HostIP           string            `protobuf:"bytes,13,opt,name=host_ip,json=hostIp,proto3" json:"host_ip,omitempty"`
	Message          string            `protobuf:"bytes,14,opt,name=message,proto3" json:"message,omitempty"`
	Reason           string            `protobuf:"bytes,15,opt,name=reason,proto3" json:"reason,omitempty"`
	Labels           string            `protobuf:"bytes,17,opt,name=labels,proto3" json:"labels,omitempty"`
	OwnerReferences  []*OwnerReference `protobuf:"bytes,18,rep,name=owner_references,json=ownerReferences,proto3" json:"owner_references,omitempty"`
}

func (m *PodUpdate) Reset()      { *m = PodUpdate{} }
func (*PodUpdate) ProtoMessage() {}
func (*PodUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{20}
}
func (m *PodUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PodUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PodUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PodUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodUpdate.Merge(m, src)
}
func (m *PodUpdate) XXX_Size() int {
	return m.Size()
}
func (m *PodUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_PodUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_PodUpdate proto.InternalMessageInfo

func (m *PodUpdate) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *PodUpdate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *PodUpdate) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *PodUpdate) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *PodUpdate) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

func (m *PodUpdate) GetContainerIDs() []string {
	if m != nil {
		return m.ContainerIDs
	}
	return nil
}

func (m *PodUpdate) GetContainerNames() []string {
	if m != nil {
		return m.ContainerNames
	}
	return nil
}

func (m *PodUpdate) GetQOSClass() PodQOSClass {
	if m != nil {
		return m.QOSClass
	}
	return QOS_CLASS_UNKNOWN
}

func (m *PodUpdate) GetPhase() PodPhase {
	if m != nil {
		return m.Phase
	}
	return PHASE_UNKNOWN
}

func (m *PodUpdate) GetConditions() []*PodCondition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

func (m *PodUpdate) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *PodUpdate) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

func (m *PodUpdate) GetPodIP() string {
	if m != nil {
		return m.PodIP
	}
	return ""
}

func (m *PodUpdate) GetHostIP() string {
	if m != nil {
		return m.HostIP
	}
	return ""
}

func (m *PodUpdate) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *PodUpdate) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *PodUpdate) GetLabels() string {
	if m != nil {
		return m.Labels
	}
	return ""
}

func (m *PodUpdate) GetOwnerReferences() []*OwnerReference {
	if m != nil {
		return m.OwnerReferences
	}
	return nil
}

type ContainerUpdate struct {
	CID              string         `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
	Name             string         `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	StartTimestampNS int64          `protobuf:"varint,3,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS  int64          `protobuf:"varint,4,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
	Namespace        string         `protobuf:"bytes,5,opt,name=namespace,proto3" json:"namespace,omitempty"`
	PodID            string         `protobuf:"bytes,6,opt,name=pod_id,json=podId,proto3" json:"pod_id,omitempty"`
	PodName          string         `protobuf:"bytes,7,opt,name=pod_name,json=podName,proto3" json:"pod_name,omitempty"`
	ContainerState   ContainerState `protobuf:"varint,8,opt,name=container_state,json=containerState,proto3,enum=px.shared.k8s.metadatapb.ContainerState" json:"container_state,omitempty"`
	Message          string         `protobuf:"bytes,9,opt,name=message,proto3" json:"message,omitempty"`
	Reason           string         `protobuf:"bytes,10,opt,name=reason,proto3" json:"reason,omitempty"`
	ContainerType    ContainerType  `protobuf:"varint,11,opt,name=container_type,json=containerType,proto3,enum=px.shared.k8s.metadatapb.ContainerType" json:"container_type,omitempty"`
}

func (m *ContainerUpdate) Reset()      { *m = ContainerUpdate{} }
func (*ContainerUpdate) ProtoMessage() {}
func (*ContainerUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{21}
}
func (m *ContainerUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ContainerUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ContainerUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ContainerUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerUpdate.Merge(m, src)
}
func (m *ContainerUpdate) XXX_Size() int {
	return m.Size()
}
func (m *ContainerUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerUpdate proto.InternalMessageInfo

func (m *ContainerUpdate) GetCID() string {
	if m != nil {
		return m.CID
	}
	return ""
}

func (m *ContainerUpdate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ContainerUpdate) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *ContainerUpdate) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

func (m *ContainerUpdate) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ContainerUpdate) GetPodID() string {
	if m != nil {
		return m.PodID
	}
	return ""
}

func (m *ContainerUpdate) GetPodName() string {
	if m != nil {
		return m.PodName
	}
	return ""
}

func (m *ContainerUpdate) GetContainerState() ContainerState {
	if m != nil {
		return m.ContainerState
	}
	return CONTAINER_STATE_UNKNOWN
}

func (m *ContainerUpdate) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *ContainerUpdate) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *ContainerUpdate) GetContainerType() ContainerType {
	if m != nil {
		return m.ContainerType
	}
	return CONTAINER_TYPE_UNKNOWN
}

type ServiceUpdate struct {
	UID              string   `protobuf:"bytes,1,opt,name=uid,proto3" json:"uid,omitempty"`
	Name             string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Namespace        string   `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
	StartTimestampNS int64    `protobuf:"varint,4,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS  int64    `protobuf:"varint,5,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
	PodIDs           []string `protobuf:"bytes,6,rep,name=pod_ids,json=podIds,proto3" json:"pod_ids,omitempty"`
	PodNames         []string `protobuf:"bytes,7,rep,name=pod_names,json=podNames,proto3" json:"pod_names,omitempty"`
	ExternalIPs      []string `protobuf:"bytes,8,rep,name=external_ips,json=externalIps,proto3" json:"external_ips,omitempty"`
	ClusterIP        string   `protobuf:"bytes,9,opt,name=cluster_ip,json=clusterIp,proto3" json:"cluster_ip,omitempty"`
}

func (m *ServiceUpdate) Reset()      { *m = ServiceUpdate{} }
func (*ServiceUpdate) ProtoMessage() {}
func (*ServiceUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{22}
}
func (m *ServiceUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ServiceUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ServiceUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ServiceUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceUpdate.Merge(m, src)
}
func (m *ServiceUpdate) XXX_Size() int {
	return m.Size()
}
func (m *ServiceUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceUpdate proto.InternalMessageInfo

func (m *ServiceUpdate) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *ServiceUpdate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ServiceUpdate) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ServiceUpdate) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *ServiceUpdate) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

func (m *ServiceUpdate) GetPodIDs() []string {
	if m != nil {
		return m.PodIDs
	}
	return nil
}

func (m *ServiceUpdate) GetPodNames() []string {
	if m != nil {
		return m.PodNames
	}
	return nil
}

func (m *ServiceUpdate) GetExternalIPs() []string {
	if m != nil {
		return m.ExternalIPs
	}
	return nil
}

func (m *ServiceUpdate) GetClusterIP() string {
	if m != nil {
		return m.ClusterIP
	}
	return ""
}

type NamespaceUpdate struct {
	UID              string `protobuf:"bytes,1,opt,name=uid,proto3" json:"uid,omitempty"`
	Name             string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	StartTimestampNS int64  `protobuf:"varint,3,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS  int64  `protobuf:"varint,4,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
}

func (m *NamespaceUpdate) Reset()      { *m = NamespaceUpdate{} }
func (*NamespaceUpdate) ProtoMessage() {}
func (*NamespaceUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{23}
}
func (m *NamespaceUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NamespaceUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NamespaceUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NamespaceUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NamespaceUpdate.Merge(m, src)
}
func (m *NamespaceUpdate) XXX_Size() int {
	return m.Size()
}
func (m *NamespaceUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_NamespaceUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_NamespaceUpdate proto.InternalMessageInfo

func (m *NamespaceUpdate) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *NamespaceUpdate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *NamespaceUpdate) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *NamespaceUpdate) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

type ProcessCreated struct {
	UPID             *typespb.UInt128 `protobuf:"bytes,1,opt,name=upid,proto3" json:"upid,omitempty"`
	StartTimestampNS int64            `protobuf:"varint,3,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	Cmdline          string           `protobuf:"bytes,4,opt,name=cmdline,proto3" json:"cmdline,omitempty"`
	CID              string           `protobuf:"bytes,5,opt,name=cid,proto3" json:"cid,omitempty"`
}

func (m *ProcessCreated) Reset()      { *m = ProcessCreated{} }
func (*ProcessCreated) ProtoMessage() {}
func (*ProcessCreated) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{24}
}
func (m *ProcessCreated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProcessCreated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProcessCreated.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ProcessCreated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProcessCreated.Merge(m, src)
}
func (m *ProcessCreated) XXX_Size() int {
	return m.Size()
}
func (m *ProcessCreated) XXX_DiscardUnknown() {
	xxx_messageInfo_ProcessCreated.DiscardUnknown(m)
}

var xxx_messageInfo_ProcessCreated proto.InternalMessageInfo

func (m *ProcessCreated) GetUPID() *typespb.UInt128 {
	if m != nil {
		return m.UPID
	}
	return nil
}

func (m *ProcessCreated) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *ProcessCreated) GetCmdline() string {
	if m != nil {
		return m.Cmdline
	}
	return ""
}

func (m *ProcessCreated) GetCID() string {
	if m != nil {
		return m.CID
	}
	return ""
}

type ProcessTerminated struct {
	UPID            *typespb.UInt128 `protobuf:"bytes,1,opt,name=upid,proto3" json:"upid,omitempty"`
	StopTimestampNS int64            `protobuf:"varint,2,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
}

func (m *ProcessTerminated) Reset()      { *m = ProcessTerminated{} }
func (*ProcessTerminated) ProtoMessage() {}
func (*ProcessTerminated) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{25}
}
func (m *ProcessTerminated) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProcessTerminated) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProcessTerminated.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ProcessTerminated) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProcessTerminated.Merge(m, src)
}
func (m *ProcessTerminated) XXX_Size() int {
	return m.Size()
}
func (m *ProcessTerminated) XXX_DiscardUnknown() {
	xxx_messageInfo_ProcessTerminated.DiscardUnknown(m)
}

var xxx_messageInfo_ProcessTerminated proto.InternalMessageInfo

func (m *ProcessTerminated) GetUPID() *typespb.UInt128 {
	if m != nil {
		return m.UPID
	}
	return nil
}

func (m *ProcessTerminated) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

type Node struct {
	Metadata *ObjectMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Spec     *NodeSpec       `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	Status   *NodeStatus     `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *Node) Reset()      { *m = Node{} }
func (*Node) ProtoMessage() {}
func (*Node) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{26}
}
func (m *Node) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Node.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Node) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Node.Merge(m, src)
}
func (m *Node) XXX_Size() int {
	return m.Size()
}
func (m *Node) XXX_DiscardUnknown() {
	xxx_messageInfo_Node.DiscardUnknown(m)
}

var xxx_messageInfo_Node proto.InternalMessageInfo

func (m *Node) GetMetadata() *ObjectMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Node) GetSpec() *NodeSpec {
	if m != nil {
		return m.Spec
	}
	return nil
}

func (m *Node) GetStatus() *NodeStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type NodeSpec struct {
	PodCIDRs []string `protobuf:"bytes,1,rep,name=pod_cidrs,json=podCidrs,proto3" json:"pod_cidrs,omitempty"`
	PodCIDR  string   `protobuf:"bytes,2,opt,name=pod_cidr,json=podCidr,proto3" json:"pod_cidr,omitempty"`
}

func (m *NodeSpec) Reset()      { *m = NodeSpec{} }
func (*NodeSpec) ProtoMessage() {}
func (*NodeSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{27}
}
func (m *NodeSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NodeSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NodeSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NodeSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeSpec.Merge(m, src)
}
func (m *NodeSpec) XXX_Size() int {
	return m.Size()
}
func (m *NodeSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeSpec.DiscardUnknown(m)
}

var xxx_messageInfo_NodeSpec proto.InternalMessageInfo

func (m *NodeSpec) GetPodCIDRs() []string {
	if m != nil {
		return m.PodCIDRs
	}
	return nil
}

func (m *NodeSpec) GetPodCIDR() string {
	if m != nil {
		return m.PodCIDR
	}
	return ""
}

type NodeAddress struct {
	Type    NodeAddressType `protobuf:"varint,1,opt,name=type,proto3,enum=px.shared.k8s.metadatapb.NodeAddressType" json:"type,omitempty"`
	Address string          `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

func (m *NodeAddress) Reset()      { *m = NodeAddress{} }
func (*NodeAddress) ProtoMessage() {}
func (*NodeAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{28}
}
func (m *NodeAddress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NodeAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NodeAddress.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NodeAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeAddress.Merge(m, src)
}
func (m *NodeAddress) XXX_Size() int {
	return m.Size()
}
func (m *NodeAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeAddress.DiscardUnknown(m)
}

var xxx_messageInfo_NodeAddress proto.InternalMessageInfo

func (m *NodeAddress) GetType() NodeAddressType {
	if m != nil {
		return m.Type
	}
	return NODE_ADDR_TYPE_UNKNOWN
}

func (m *NodeAddress) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

type NodeCondition struct {
	Type   NodeConditionType `protobuf:"varint,1,opt,name=type,proto3,enum=px.shared.k8s.metadatapb.NodeConditionType" json:"type,omitempty"`
	Status ConditionStatus   `protobuf:"varint,2,opt,name=status,proto3,enum=px.shared.k8s.metadatapb.ConditionStatus" json:"status,omitempty"`
}

func (m *NodeCondition) Reset()      { *m = NodeCondition{} }
func (*NodeCondition) ProtoMessage() {}
func (*NodeCondition) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{29}
}
func (m *NodeCondition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NodeCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NodeCondition.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NodeCondition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeCondition.Merge(m, src)
}
func (m *NodeCondition) XXX_Size() int {
	return m.Size()
}
func (m *NodeCondition) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeCondition.DiscardUnknown(m)
}

var xxx_messageInfo_NodeCondition proto.InternalMessageInfo

func (m *NodeCondition) GetType() NodeConditionType {
	if m != nil {
		return m.Type
	}
	return NODE_CONDITION_UNKNOWN
}

func (m *NodeCondition) GetStatus() ConditionStatus {
	if m != nil {
		return m.Status
	}
	return CONDITION_STATUS_UNKNOWN
}

type NodeStatus struct {
	Phase      NodePhase        `protobuf:"varint,1,opt,name=phase,proto3,enum=px.shared.k8s.metadatapb.NodePhase" json:"phase,omitempty"`
	Addresses  []*NodeAddress   `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
	Conditions []*NodeCondition `protobuf:"bytes,3,rep,name=conditions,proto3" json:"conditions,omitempty"`
}

func (m *NodeStatus) Reset()      { *m = NodeStatus{} }
func (*NodeStatus) ProtoMessage() {}
func (*NodeStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{30}
}
func (m *NodeStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NodeStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NodeStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NodeStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeStatus.Merge(m, src)
}
func (m *NodeStatus) XXX_Size() int {
	return m.Size()
}
func (m *NodeStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeStatus.DiscardUnknown(m)
}

var xxx_messageInfo_NodeStatus proto.InternalMessageInfo

func (m *NodeStatus) GetPhase() NodePhase {
	if m != nil {
		return m.Phase
	}
	return NODE_PHASE_UNKNOWN
}

func (m *NodeStatus) GetAddresses() []*NodeAddress {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *NodeStatus) GetConditions() []*NodeCondition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

type NodeUpdate struct {
	UID              string           `protobuf:"bytes,1,opt,name=uid,proto3" json:"uid,omitempty"`
	Name             string           `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	StartTimestampNS int64            `protobuf:"varint,3,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS  int64            `protobuf:"varint,4,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
	Phase            NodePhase        `protobuf:"varint,5,opt,name=phase,proto3,enum=px.shared.k8s.metadatapb.NodePhase" json:"phase,omitempty"`
	PodCIDR          string           `protobuf:"bytes,6,opt,name=pod_cidr,json=podCidr,proto3" json:"pod_cidr,omitempty"`
	PodCIDRs         []string         `protobuf:"bytes,7,rep,name=pod_cidrs,json=podCidrs,proto3" json:"pod_cidrs,omitempty"`
	Conditions       []*NodeCondition `protobuf:"bytes,8,rep,name=conditions,proto3" json:"conditions,omitempty"`
}

func (m *NodeUpdate) Reset()      { *m = NodeUpdate{} }
func (*NodeUpdate) ProtoMessage() {}
func (*NodeUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{31}
}
func (m *NodeUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NodeUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NodeUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NodeUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeUpdate.Merge(m, src)
}
func (m *NodeUpdate) XXX_Size() int {
	return m.Size()
}
func (m *NodeUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_NodeUpdate proto.InternalMessageInfo

func (m *NodeUpdate) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *NodeUpdate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *NodeUpdate) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *NodeUpdate) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

func (m *NodeUpdate) GetPhase() NodePhase {
	if m != nil {
		return m.Phase
	}
	return NODE_PHASE_UNKNOWN
}

func (m *NodeUpdate) GetPodCIDR() string {
	if m != nil {
		return m.PodCIDR
	}
	return ""
}

func (m *NodeUpdate) GetPodCIDRs() []string {
	if m != nil {
		return m.PodCIDRs
	}
	return nil
}

func (m *NodeUpdate) GetConditions() []*NodeCondition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

type ReplicaSet struct {
	Metadata *ObjectMetadata   `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Spec     *ReplicaSetSpec   `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	Status   *ReplicaSetStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *ReplicaSet) Reset()      { *m = ReplicaSet{} }
func (*ReplicaSet) ProtoMessage() {}
func (*ReplicaSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{32}
}
func (m *ReplicaSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicaSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicaSet.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReplicaSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicaSet.Merge(m, src)
}
func (m *ReplicaSet) XXX_Size() int {
	return m.Size()
}
func (m *ReplicaSet) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicaSet.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicaSet proto.InternalMessageInfo

func (m *ReplicaSet) GetMetadata() *ObjectMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *ReplicaSet) GetSpec() *ReplicaSetSpec {
	if m != nil {
		return m.Spec
	}
	return nil
}

func (m *ReplicaSet) GetStatus() *ReplicaSetStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type ReplicaSetCondition struct {
	Type   string          `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Status ConditionStatus `protobuf:"varint,2,opt,name=status,proto3,enum=px.shared.k8s.metadatapb.ConditionStatus" json:"status,omitempty"`
}

func (m *ReplicaSetCondition) Reset()      { *m = ReplicaSetCondition{} }
func (*ReplicaSetCondition) ProtoMessage() {}
func (*ReplicaSetCondition) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{33}
}
func (m *ReplicaSetCondition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicaSetCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicaSetCondition.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReplicaSetCondition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicaSetCondition.Merge(m, src)
}
func (m *ReplicaSetCondition) XXX_Size() int {
	return m.Size()
}
func (m *ReplicaSetCondition) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicaSetCondition.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicaSetCondition proto.InternalMessageInfo

func (m *ReplicaSetCondition) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *ReplicaSetCondition) GetStatus() ConditionStatus {
	if m != nil {
		return m.Status
	}
	return CONDITION_STATUS_UNKNOWN
}

type LabelSelectorRequirement struct {
	Key      string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Operator string   `protobuf:"bytes,2,opt,name=operator,proto3" json:"operator,omitempty"`
	Values   []string `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"`
}

func (m *LabelSelectorRequirement) Reset()      { *m = LabelSelectorRequirement{} }
func (*LabelSelectorRequirement) ProtoMessage() {}
func (*LabelSelectorRequirement) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{34}
}
func (m *LabelSelectorRequirement) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LabelSelectorRequirement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LabelSelectorRequirement.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LabelSelectorRequirement) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LabelSelectorRequirement.Merge(m, src)
}
func (m *LabelSelectorRequirement) XXX_Size() int {
	return m.Size()
}
func (m *LabelSelectorRequirement) XXX_DiscardUnknown() {
	xxx_messageInfo_LabelSelectorRequirement.DiscardUnknown(m)
}

var xxx_messageInfo_LabelSelectorRequirement proto.InternalMessageInfo

func (m *LabelSelectorRequirement) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *LabelSelectorRequirement) GetOperator() string {
	if m != nil {
		return m.Operator
	}
	return ""
}

func (m *LabelSelectorRequirement) GetValues() []string {
	if m != nil {
		return m.Values
	}
	return nil
}

type LabelSelector struct {
	MatchLabels      map[string]string           `protobuf:"bytes,1,rep,name=match_labels,json=matchLabels,proto3" json:"match_labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	MatchExpressions []*LabelSelectorRequirement `protobuf:"bytes,2,rep,name=match_expressions,json=matchExpressions,proto3" json:"match_expressions,omitempty"`
}

func (m *LabelSelector) Reset()      { *m = LabelSelector{} }
func (*LabelSelector) ProtoMessage() {}
func (*LabelSelector) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{35}
}
func (m *LabelSelector) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LabelSelector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LabelSelector.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LabelSelector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LabelSelector.Merge(m, src)
}
func (m *LabelSelector) XXX_Size() int {
	return m.Size()
}
func (m *LabelSelector) XXX_DiscardUnknown() {
	xxx_messageInfo_LabelSelector.DiscardUnknown(m)
}

var xxx_messageInfo_LabelSelector proto.InternalMessageInfo

func (m *LabelSelector) GetMatchLabels() map[string]string {
	if m != nil {
		return m.MatchLabels
	}
	return nil
}

func (m *LabelSelector) GetMatchExpressions() []*LabelSelectorRequirement {
	if m != nil {
		return m.MatchExpressions
	}
	return nil
}

type PodTemplateSpec struct {
	Metadata *ObjectMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Spec     *PodSpec        `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
}

func (m *PodTemplateSpec) Reset()      { *m = PodTemplateSpec{} }
func (*PodTemplateSpec) ProtoMessage() {}
func (*PodTemplateSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{36}
}
func (m *PodTemplateSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PodTemplateSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PodTemplateSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PodTemplateSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PodTemplateSpec.Merge(m, src)
}
func (m *PodTemplateSpec) XXX_Size() int {
	return m.Size()
}
func (m *PodTemplateSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_PodTemplateSpec.DiscardUnknown(m)
}

var xxx_messageInfo_PodTemplateSpec proto.InternalMessageInfo

func (m *PodTemplateSpec) GetMetadata() *ObjectMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *PodTemplateSpec) GetSpec() *PodSpec {
	if m != nil {
		return m.Spec
	}
	return nil
}

type ReplicaSetSpec struct {
	Replicas        int32            `protobuf:"varint,1,opt,name=replicas,proto3" json:"replicas,omitempty"`
	MinReadySeconds int32            `protobuf:"varint,4,opt,name=min_ready_seconds,json=minReadySeconds,proto3" json:"min_ready_seconds,omitempty"`
	Selector        *LabelSelector   `protobuf:"bytes,2,opt,name=selector,proto3" json:"selector,omitempty"`
	Template        *PodTemplateSpec `protobuf:"bytes,3,opt,name=template,proto3" json:"template,omitempty"`
}

func (m *ReplicaSetSpec) Reset()      { *m = ReplicaSetSpec{} }
func (*ReplicaSetSpec) ProtoMessage() {}
func (*ReplicaSetSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{37}
}
func (m *ReplicaSetSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicaSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicaSetSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReplicaSetSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicaSetSpec.Merge(m, src)
}
func (m *ReplicaSetSpec) XXX_Size() int {
	return m.Size()
}
func (m *ReplicaSetSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicaSetSpec.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicaSetSpec proto.InternalMessageInfo

func (m *ReplicaSetSpec) GetReplicas() int32 {
	if m != nil {
		return m.Replicas
	}
	return 0
}

func (m *ReplicaSetSpec) GetMinReadySeconds() int32 {
	if m != nil {
		return m.MinReadySeconds
	}
	return 0
}

func (m *ReplicaSetSpec) GetSelector() *LabelSelector {
	if m != nil {
		return m.Selector
	}
	return nil
}

func (m *ReplicaSetSpec) GetTemplate() *PodTemplateSpec {
	if m != nil {
		return m.Template
	}
	return nil
}

type ReplicaSetStatus struct {
	Replicas             int32                  `protobuf:"varint,1,opt,name=replicas,proto3" json:"replicas,omitempty"`
	FullyLabeledReplicas int32                  `protobuf:"varint,2,opt,name=fully_labeled_replicas,json=fullyLabeledReplicas,proto3" json:"fully_labeled_replicas,omitempty"`
	ReadyReplicas        int32                  `protobuf:"varint,4,opt,name=ready_replicas,json=readyReplicas,proto3" json:"ready_replicas,omitempty"`
	AvailableReplicas    int32                  `protobuf:"varint,5,opt,name=available_replicas,json=availableReplicas,proto3" json:"available_replicas,omitempty"`
	ObservedGeneration   int64                  `protobuf:"varint,3,opt,name=observed_generation,json=observedGeneration,proto3" json:"observed_generation,omitempty"`
	Conditions           []*ReplicaSetCondition `protobuf:"bytes,6,rep,name=conditions,proto3" json:"conditions,omitempty"`
}

func (m *ReplicaSetStatus) Reset()      { *m = ReplicaSetStatus{} }
func (*ReplicaSetStatus) ProtoMessage() {}
func (*ReplicaSetStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{38}
}
func (m *ReplicaSetStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicaSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicaSetStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReplicaSetStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicaSetStatus.Merge(m, src)
}
func (m *ReplicaSetStatus) XXX_Size() int {
	return m.Size()
}
func (m *ReplicaSetStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicaSetStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicaSetStatus proto.InternalMessageInfo

func (m *ReplicaSetStatus) GetReplicas() int32 {
	if m != nil {
		return m.Replicas
	}
	return 0
}

func (m *ReplicaSetStatus) GetFullyLabeledReplicas() int32 {
	if m != nil {
		return m.FullyLabeledReplicas
	}
	return 0
}

func (m *ReplicaSetStatus) GetReadyReplicas() int32 {
	if m != nil {
		return m.ReadyReplicas
	}
	return 0
}

func (m *ReplicaSetStatus) GetAvailableReplicas() int32 {
	if m != nil {
		return m.AvailableReplicas
	}
	return 0
}

func (m *ReplicaSetStatus) GetObservedGeneration() int64 {
	if m != nil {
		return m.ObservedGeneration
	}
	return 0
}

func (m *ReplicaSetStatus) GetConditions() []*ReplicaSetCondition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

type ReplicaSetUpdate struct {
	UID                  string                 `protobuf:"bytes,1,opt,name=uid,proto3" json:"uid,omitempty"`
	Name                 string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	StartTimestampNS     int64                  `protobuf:"varint,3,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS      int64                  `protobuf:"varint,4,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
	Namespace            string                 `protobuf:"bytes,12,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Replicas             int32                  `protobuf:"varint,5,opt,name=replicas,proto3" json:"replicas,omitempty"`
	FullyLabeledReplicas int32                  `protobuf:"varint,6,opt,name=fully_labeled_replicas,json=fullyLabeledReplicas,proto3" json:"fully_labeled_replicas,omitempty"`
	ReadyReplicas        int32                  `protobuf:"varint,7,opt,name=ready_replicas,json=readyReplicas,proto3" json:"ready_replicas,omitempty"`
	AvailableReplicas    int32                  `protobuf:"varint,8,opt,name=available_replicas,json=availableReplicas,proto3" json:"available_replicas,omitempty"`
	ObservedGeneration   int32                  `protobuf:"varint,9,opt,name=observed_generation,json=observedGeneration,proto3" json:"observed_generation,omitempty"`
	RequestedReplicas    int32                  `protobuf:"varint,13,opt,name=requested_replicas,json=requestedReplicas,proto3" json:"requested_replicas,omitempty"`
	Conditions           []*ReplicaSetCondition `protobuf:"bytes,10,rep,name=conditions,proto3" json:"conditions,omitempty"`
	OwnerReferences      []*OwnerReference      `protobuf:"bytes,11,rep,name=owner_references,json=ownerReferences,proto3" json:"owner_references,omitempty"`
}

func (m *ReplicaSetUpdate) Reset()      { *m = ReplicaSetUpdate{} }
func (*ReplicaSetUpdate) ProtoMessage() {}
func (*ReplicaSetUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{39}
}
func (m *ReplicaSetUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicaSetUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReplicaSetUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ReplicaSetUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicaSetUpdate.Merge(m, src)
}
func (m *ReplicaSetUpdate) XXX_Size() int {
	return m.Size()
}
func (m *ReplicaSetUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicaSetUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicaSetUpdate proto.InternalMessageInfo

func (m *ReplicaSetUpdate) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *ReplicaSetUpdate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ReplicaSetUpdate) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *ReplicaSetUpdate) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

func (m *ReplicaSetUpdate) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ReplicaSetUpdate) GetReplicas() int32 {
	if m != nil {
		return m.Replicas
	}
	return 0
}

func (m *ReplicaSetUpdate) GetFullyLabeledReplicas() int32 {
	if m != nil {
		return m.FullyLabeledReplicas
	}
	return 0
}

func (m *ReplicaSetUpdate) GetReadyReplicas() int32 {
	if m != nil {
		return m.ReadyReplicas
	}
	return 0
}

func (m *ReplicaSetUpdate) GetAvailableReplicas() int32 {
	if m != nil {
		return m.AvailableReplicas
	}
	return 0
}

func (m *ReplicaSetUpdate) GetObservedGeneration() int32 {
	if m != nil {
		return m.ObservedGeneration
	}
	return 0
}

func (m *ReplicaSetUpdate) GetRequestedReplicas() int32 {
	if m != nil {
		return m.RequestedReplicas
	}
	return 0
}

func (m *ReplicaSetUpdate) GetConditions() []*ReplicaSetCondition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

func (m *ReplicaSetUpdate) GetOwnerReferences() []*OwnerReference {
	if m != nil {
		return m.OwnerReferences
	}
	return nil
}

type Deployment struct {
	Metadata *ObjectMetadata   `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Spec     *DeploymentSpec   `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
	Status   *DeploymentStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *Deployment) Reset()      { *m = Deployment{} }
func (*Deployment) ProtoMessage() {}
func (*Deployment) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{40}
}
func (m *Deployment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Deployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Deployment.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Deployment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Deployment.Merge(m, src)
}
func (m *Deployment) XXX_Size() int {
	return m.Size()
}
func (m *Deployment) XXX_DiscardUnknown() {
	xxx_messageInfo_Deployment.DiscardUnknown(m)
}

var xxx_messageInfo_Deployment proto.InternalMessageInfo

func (m *Deployment) GetMetadata() *ObjectMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

func (m *Deployment) GetSpec() *DeploymentSpec {
	if m != nil {
		return m.Spec
	}
	return nil
}

func (m *Deployment) GetStatus() *DeploymentStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type DeploymentCondition struct {
	Type                 DeploymentConditionType `protobuf:"varint,1,opt,name=type,proto3,enum=px.shared.k8s.metadatapb.DeploymentConditionType" json:"type,omitempty"`
	Status               ConditionStatus         `protobuf:"varint,2,opt,name=status,proto3,enum=px.shared.k8s.metadatapb.ConditionStatus" json:"status,omitempty"`
	LastUpdateTimeNS     int64                   `protobuf:"varint,3,opt,name=last_update_time_ns,json=lastUpdateTimeNs,proto3" json:"last_update_time_ns,omitempty"`
	LastTransitionTimeNS int64                   `protobuf:"varint,4,opt,name=last_transition_time_ns,json=lastTransitionTimeNs,proto3" json:"last_transition_time_ns,omitempty"`
	Reason               string                  `protobuf:"bytes,5,opt,name=reason,proto3" json:"reason,omitempty"`
	Message              string                  `protobuf:"bytes,6,opt,name=message,proto3" json:"message,omitempty"`
}

func (m *DeploymentCondition) Reset()      { *m = DeploymentCondition{} }
func (*DeploymentCondition) ProtoMessage() {}
func (*DeploymentCondition) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{41}
}
func (m *DeploymentCondition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentCondition.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentCondition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentCondition.Merge(m, src)
}
func (m *DeploymentCondition) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentCondition) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentCondition.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentCondition proto.InternalMessageInfo

func (m *DeploymentCondition) GetType() DeploymentConditionType {
	if m != nil {
		return m.Type
	}
	return DEPLOYMENT_CONDITION_TYPE_UNKNOWN
}

func (m *DeploymentCondition) GetStatus() ConditionStatus {
	if m != nil {
		return m.Status
	}
	return CONDITION_STATUS_UNKNOWN
}

func (m *DeploymentCondition) GetLastUpdateTimeNS() int64 {
	if m != nil {
		return m.LastUpdateTimeNS
	}
	return 0
}

func (m *DeploymentCondition) GetLastTransitionTimeNS() int64 {
	if m != nil {
		return m.LastTransitionTimeNS
	}
	return 0
}

func (m *DeploymentCondition) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *DeploymentCondition) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type DeploymentStatus struct {
	ObservedGeneration  int64                  `protobuf:"varint,1,opt,name=observed_generation,json=observedGeneration,proto3" json:"observed_generation,omitempty"`
	Replicas            int32                  `protobuf:"varint,2,opt,name=replicas,proto3" json:"replicas,omitempty"`
	UpdatedReplicas     int32                  `protobuf:"varint,3,opt,name=updated_replicas,json=updatedReplicas,proto3" json:"updated_replicas,omitempty"`
	ReadyReplicas       int32                  `protobuf:"varint,4,opt,name=ready_replicas,json=readyReplicas,proto3" json:"ready_replicas,omitempty"`
	AvailableReplicas   int32                  `protobuf:"varint,5,opt,name=available_replicas,json=availableReplicas,proto3" json:"available_replicas,omitempty"`
	UnavailableReplicas int32                  `protobuf:"varint,6,opt,name=unavailable_replicas,json=unavailableReplicas,proto3" json:"unavailable_replicas,omitempty"`
	Conditions          []*DeploymentCondition `protobuf:"bytes,7,rep,name=conditions,proto3" json:"conditions,omitempty"`
	CollisionCount      int32                  `protobuf:"varint,8,opt,name=collision_count,json=collisionCount,proto3" json:"collision_count,omitempty"`
}

func (m *DeploymentStatus) Reset()      { *m = DeploymentStatus{} }
func (*DeploymentStatus) ProtoMessage() {}
func (*DeploymentStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{42}
}
func (m *DeploymentStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentStatus.Merge(m, src)
}
func (m *DeploymentStatus) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentStatus.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentStatus proto.InternalMessageInfo

func (m *DeploymentStatus) GetObservedGeneration() int64 {
	if m != nil {
		return m.ObservedGeneration
	}
	return 0
}

func (m *DeploymentStatus) GetReplicas() int32 {
	if m != nil {
		return m.Replicas
	}
	return 0
}

func (m *DeploymentStatus) GetUpdatedReplicas() int32 {
	if m != nil {
		return m.UpdatedReplicas
	}
	return 0
}

func (m *DeploymentStatus) GetReadyReplicas() int32 {
	if m != nil {
		return m.ReadyReplicas
	}
	return 0
}

func (m *DeploymentStatus) GetAvailableReplicas() int32 {
	if m != nil {
		return m.AvailableReplicas
	}
	return 0
}

func (m *DeploymentStatus) GetUnavailableReplicas() int32 {
	if m != nil {
		return m.UnavailableReplicas
	}
	return 0
}

func (m *DeploymentStatus) GetConditions() []*DeploymentCondition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

func (m *DeploymentStatus) GetCollisionCount() int32 {
	if m != nil {
		return m.CollisionCount
	}
	return 0
}

type DeploymentSpec struct {
	Replicas                int32               `protobuf:"varint,1,opt,name=replicas,proto3" json:"replicas,omitempty"`
	Selector                *LabelSelector      `protobuf:"bytes,2,opt,name=selector,proto3" json:"selector,omitempty"`
	Template                *PodTemplateSpec    `protobuf:"bytes,3,opt,name=template,proto3" json:"template,omitempty"`
	Strategy                *DeploymentStrategy `protobuf:"bytes,4,opt,name=strategy,proto3" json:"strategy,omitempty"`
	MinReadySeconds         int32               `protobuf:"varint,5,opt,name=min_ready_seconds,json=minReadySeconds,proto3" json:"min_ready_seconds,omitempty"`
	RevisionHistoryLimit    int32               `protobuf:"varint,6,opt,name=revision_history_limit,json=revisionHistoryLimit,proto3" json:"revision_history_limit,omitempty"`
	Paused                  bool                `protobuf:"varint,7,opt,name=paused,proto3" json:"paused,omitempty"`
	ProgressDeadlineSeconds int32               `protobuf:"varint,9,opt,name=progress_deadline_seconds,json=progressDeadlineSeconds,proto3" json:"progress_deadline_seconds,omitempty"`
}

func (m *DeploymentSpec) Reset()      { *m = DeploymentSpec{} }
func (*DeploymentSpec) ProtoMessage() {}
func (*DeploymentSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{43}
}
func (m *DeploymentSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentSpec.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentSpec.Merge(m, src)
}
func (m *DeploymentSpec) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentSpec.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentSpec proto.InternalMessageInfo

func (m *DeploymentSpec) GetReplicas() int32 {
	if m != nil {
		return m.Replicas
	}
	return 0
}

func (m *DeploymentSpec) GetSelector() *LabelSelector {
	if m != nil {
		return m.Selector
	}
	return nil
}

func (m *DeploymentSpec) GetTemplate() *PodTemplateSpec {
	if m != nil {
		return m.Template
	}
	return nil
}

func (m *DeploymentSpec) GetStrategy() *DeploymentStrategy {
	if m != nil {
		return m.Strategy
	}
	return nil
}

func (m *DeploymentSpec) GetMinReadySeconds() int32 {
	if m != nil {
		return m.MinReadySeconds
	}
	return 0
}

func (m *DeploymentSpec) GetRevisionHistoryLimit() int32 {
	if m != nil {
		return m.RevisionHistoryLimit
	}
	return 0
}

func (m *DeploymentSpec) GetPaused() bool {
	if m != nil {
		return m.Paused
	}
	return false
}

func (m *DeploymentSpec) GetProgressDeadlineSeconds() int32 {
	if m != nil {
		return m.ProgressDeadlineSeconds
	}
	return 0
}

type DeploymentStrategy struct {
	Type          DeploymentStrategyType   `protobuf:"varint,1,opt,name=type,proto3,enum=px.shared.k8s.metadatapb.DeploymentStrategyType" json:"type,omitempty"`
	RollingUpdate *RollingUpdateDeployment `protobuf:"bytes,2,opt,name=rolling_update,json=rollingUpdate,proto3" json:"rolling_update,omitempty"`
}

func (m *DeploymentStrategy) Reset()      { *m = DeploymentStrategy{} }
func (*DeploymentStrategy) ProtoMessage() {}
func (*DeploymentStrategy) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{44}
}
func (m *DeploymentStrategy) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentStrategy.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentStrategy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentStrategy.Merge(m, src)
}
func (m *DeploymentStrategy) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentStrategy) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentStrategy.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentStrategy proto.InternalMessageInfo

func (m *DeploymentStrategy) GetType() DeploymentStrategyType {
	if m != nil {
		return m.Type
	}
	return DEPLOYMENT_STRATEGY_UNKNOWN
}

func (m *DeploymentStrategy) GetRollingUpdate() *RollingUpdateDeployment {
	if m != nil {
		return m.RollingUpdate
	}
	return nil
}

type RollingUpdateDeployment struct {
	MaxUnavailable string `protobuf:"bytes,1,opt,name=max_unavailable,json=maxUnavailable,proto3" json:"max_unavailable,omitempty"`
	MaxSurge       string `protobuf:"bytes,2,opt,name=max_surge,json=maxSurge,proto3" json:"max_surge,omitempty"`
}

func (m *RollingUpdateDeployment) Reset()      { *m = RollingUpdateDeployment{} }
func (*RollingUpdateDeployment) ProtoMessage() {}
func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{45}
}
func (m *RollingUpdateDeployment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RollingUpdateDeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RollingUpdateDeployment.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RollingUpdateDeployment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RollingUpdateDeployment.Merge(m, src)
}
func (m *RollingUpdateDeployment) XXX_Size() int {
	return m.Size()
}
func (m *RollingUpdateDeployment) XXX_DiscardUnknown() {
	xxx_messageInfo_RollingUpdateDeployment.DiscardUnknown(m)
}

var xxx_messageInfo_RollingUpdateDeployment proto.InternalMessageInfo

func (m *RollingUpdateDeployment) GetMaxUnavailable() string {
	if m != nil {
		return m.MaxUnavailable
	}
	return ""
}

func (m *RollingUpdateDeployment) GetMaxSurge() string {
	if m != nil {
		return m.MaxSurge
	}
	return ""
}

type DeploymentUpdate struct {
	UID                 string                 `protobuf:"bytes,1,opt,name=uid,proto3" json:"uid,omitempty"`
	Name                string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	StartTimestampNS    int64                  `protobuf:"varint,3,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	StopTimestampNS     int64                  `protobuf:"varint,4,opt,name=stop_timestamp_ns,json=stopTimestampNs,proto3" json:"stop_timestamp_ns,omitempty"`
	Namespace           string                 `protobuf:"bytes,5,opt,name=namespace,proto3" json:"namespace,omitempty"`
	ObservedGeneration  int32                  `protobuf:"varint,6,opt,name=observed_generation,json=observedGeneration,proto3" json:"observed_generation,omitempty"`
	Replicas            int32                  `protobuf:"varint,7,opt,name=replicas,proto3" json:"replicas,omitempty"`
	UpdatedReplicas     int32                  `protobuf:"varint,8,opt,name=updated_replicas,json=updatedReplicas,proto3" json:"updated_replicas,omitempty"`
	ReadyReplicas       int32                  `protobuf:"varint,9,opt,name=ready_replicas,json=readyReplicas,proto3" json:"ready_replicas,omitempty"`
	AvailableReplicas   int32                  `protobuf:"varint,10,opt,name=available_replicas,json=availableReplicas,proto3" json:"available_replicas,omitempty"`
	UnavailableReplicas int32                  `protobuf:"varint,11,opt,name=unavailable_replicas,json=unavailableReplicas,proto3" json:"unavailable_replicas,omitempty"`
	RequestedReplicas   int32                  `protobuf:"varint,13,opt,name=requested_replicas,json=requestedReplicas,proto3" json:"requested_replicas,omitempty"`
	Conditions          []*DeploymentCondition `protobuf:"bytes,12,rep,name=conditions,proto3" json:"conditions,omitempty"`
}

func (m *DeploymentUpdate) Reset()      { *m = DeploymentUpdate{} }
func (*DeploymentUpdate) ProtoMessage() {}
func (*DeploymentUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{46}
}
func (m *DeploymentUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeploymentUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeploymentUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DeploymentUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeploymentUpdate.Merge(m, src)
}
func (m *DeploymentUpdate) XXX_Size() int {
	return m.Size()
}
func (m *DeploymentUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_DeploymentUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_DeploymentUpdate proto.InternalMessageInfo

func (m *DeploymentUpdate) GetUID() string {
	if m != nil {
		return m.UID
	}
	return ""
}

func (m *DeploymentUpdate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *DeploymentUpdate) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *DeploymentUpdate) GetStopTimestampNS() int64 {
	if m != nil {
		return m.StopTimestampNS
	}
	return 0
}

func (m *DeploymentUpdate) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *DeploymentUpdate) GetObservedGeneration() int32 {
	if m != nil {
		return m.ObservedGeneration
	}
	return 0
}

func (m *DeploymentUpdate) GetReplicas() int32 {
	if m != nil {
		return m.Replicas
	}
	return 0
}

func (m *DeploymentUpdate) GetUpdatedReplicas() int32 {
	if m != nil {
		return m.UpdatedReplicas
	}
	return 0
}

func (m *DeploymentUpdate) GetReadyReplicas() int32 {
	if m != nil {
		return m.ReadyReplicas
	}
	return 0
}

func (m *DeploymentUpdate) GetAvailableReplicas() int32 {
	if m != nil {
		return m.AvailableReplicas
	}
	return 0
}

func (m *DeploymentUpdate) GetUnavailableReplicas() int32 {
	if m != nil {
		return m.UnavailableReplicas
	}
	return 0
}

func (m *DeploymentUpdate) GetRequestedReplicas() int32 {
	if m != nil {
		return m.RequestedReplicas
	}
	return 0
}

func (m *DeploymentUpdate) GetConditions() []*DeploymentCondition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

type ResourceUpdate struct {
	// Types that are valid to be assigned to Update:
	//
	//	*ResourceUpdate_PodUpdate
	//	*ResourceUpdate_ContainerUpdate
	//	*ResourceUpdate_ServiceUpdate
	//	*ResourceUpdate_NamespaceUpdate
	//	*ResourceUpdate_NodeUpdate
	//	*ResourceUpdate_ReplicaSetUpdate
	//	*ResourceUpdate_DeploymentUpdate
	Update            isResourceUpdate_Update `protobuf_oneof:"update"`
	UpdateVersion     int64                   `protobuf:"varint,8,opt,name=update_version,json=updateVersion,proto3" json:"update_version,omitempty"`
	PrevUpdateVersion int64                   `protobuf:"varint,9,opt,name=prev_update_version,json=prevUpdateVersion,proto3" json:"prev_update_version,omitempty"`
}

func (m *ResourceUpdate) Reset()      { *m = ResourceUpdate{} }
func (*ResourceUpdate) ProtoMessage() {}
func (*ResourceUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{47}
}
func (m *ResourceUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResourceUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ResourceUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ResourceUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResourceUpdate.Merge(m, src)
}
func (m *ResourceUpdate) XXX_Size() int {
	return m.Size()
}
func (m *ResourceUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_ResourceUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_ResourceUpdate proto.InternalMessageInfo

type isResourceUpdate_Update interface {
	isResourceUpdate_Update()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type ResourceUpdate_PodUpdate struct {
	PodUpdate *PodUpdate `protobuf:"bytes,1,opt,name=pod_update,json=podUpdate,proto3,oneof" json:"pod_update,omitempty"`
}
type ResourceUpdate_ContainerUpdate struct {
	ContainerUpdate *ContainerUpdate `protobuf:"bytes,2,opt,name=container_update,json=containerUpdate,proto3,oneof" json:"container_update,omitempty"`
}
type ResourceUpdate_ServiceUpdate struct {
	ServiceUpdate *ServiceUpdate `protobuf:"bytes,3,opt,name=service_update,json=serviceUpdate,proto3,oneof" json:"service_update,omitempty"`
}
type ResourceUpdate_NamespaceUpdate struct {
	NamespaceUpdate *NamespaceUpdate `protobuf:"bytes,6,opt,name=namespace_update,json=namespaceUpdate,proto3,oneof" json:"namespace_update,omitempty"`
}
type ResourceUpdate_NodeUpdate struct {
	NodeUpdate *NodeUpdate `protobuf:"bytes,7,opt,name=node_update,json=nodeUpdate,proto3,oneof" json:"node_update,omitempty"`
}
type ResourceUpdate_ReplicaSetUpdate struct {
	ReplicaSetUpdate *ReplicaSetUpdate `protobuf:"bytes,10,opt,name=replica_set_update,json=replicaSetUpdate,proto3,oneof" json:"replica_set_update,omitempty"`
}
type ResourceUpdate_DeploymentUpdate struct {
	DeploymentUpdate *DeploymentUpdate `protobuf:"bytes,11,opt,name=deployment_update,json=deploymentUpdate,proto3,oneof" json:"deployment_update,omitempty"`
}

func (*ResourceUpdate_PodUpdate) isResourceUpdate_Update()        {}
func (*ResourceUpdate_ContainerUpdate) isResourceUpdate_Update()  {}
func (*ResourceUpdate_ServiceUpdate) isResourceUpdate_Update()    {}
func (*ResourceUpdate_NamespaceUpdate) isResourceUpdate_Update()  {}
func (*ResourceUpdate_NodeUpdate) isResourceUpdate_Update()       {}
func (*ResourceUpdate_ReplicaSetUpdate) isResourceUpdate_Update() {}
func (*ResourceUpdate_DeploymentUpdate) isResourceUpdate_Update() {}

func (m *ResourceUpdate) GetUpdate() isResourceUpdate_Update {
	if m != nil {
		return m.Update
	}
	return nil
}

func (m *ResourceUpdate) GetPodUpdate() *PodUpdate {
	if x, ok := m.GetUpdate().(*ResourceUpdate_PodUpdate); ok {
		return x.PodUpdate
	}
	return nil
}

func (m *ResourceUpdate) GetContainerUpdate() *ContainerUpdate {
	if x, ok := m.GetUpdate().(*ResourceUpdate_ContainerUpdate); ok {
		return x.ContainerUpdate
	}
	return nil
}

func (m *ResourceUpdate) GetServiceUpdate() *ServiceUpdate {
	if x, ok := m.GetUpdate().(*ResourceUpdate_ServiceUpdate); ok {
		return x.ServiceUpdate
	}
	return nil
}

func (m *ResourceUpdate) GetNamespaceUpdate() *NamespaceUpdate {
	if x, ok := m.GetUpdate().(*ResourceUpdate_NamespaceUpdate); ok {
		return x.NamespaceUpdate
	}
	return nil
}

func (m *ResourceUpdate) GetNodeUpdate() *NodeUpdate {
	if x, ok := m.GetUpdate().(*ResourceUpdate_NodeUpdate); ok {
		return x.NodeUpdate
	}
	return nil
}

func (m *ResourceUpdate) GetReplicaSetUpdate() *ReplicaSetUpdate {
	if x, ok := m.GetUpdate().(*ResourceUpdate_ReplicaSetUpdate); ok {
		return x.ReplicaSetUpdate
	}
	return nil
}

func (m *ResourceUpdate) GetDeploymentUpdate() *DeploymentUpdate {
	if x, ok := m.GetUpdate().(*ResourceUpdate_DeploymentUpdate); ok {
		return x.DeploymentUpdate
	}
	return nil
}

func (m *ResourceUpdate) GetUpdateVersion() int64 {
	if m != nil {
		return m.UpdateVersion
	}
	return 0
}

func (m *ResourceUpdate) GetPrevUpdateVersion() int64 {
	if m != nil {
		return m.PrevUpdateVersion
	}
	return 0
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ResourceUpdate) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ResourceUpdate_PodUpdate)(nil),
		(*ResourceUpdate_ContainerUpdate)(nil),
		(*ResourceUpdate_ServiceUpdate)(nil),
		(*ResourceUpdate_NamespaceUpdate)(nil),
		(*ResourceUpdate_NodeUpdate)(nil),
		(*ResourceUpdate_ReplicaSetUpdate)(nil),
		(*ResourceUpdate_DeploymentUpdate)(nil),
	}
}

type MissingK8SMetadataRequest struct {
	Selector          string `protobuf:"bytes,1,opt,name=selector,proto3" json:"selector,omitempty"`
	FromUpdateVersion int64  `protobuf:"varint,3,opt,name=from_update_version,json=fromUpdateVersion,proto3" json:"from_update_version,omitempty"`
	ToUpdateVersion   int64  `protobuf:"varint,2,opt,name=to_update_version,json=toUpdateVersion,proto3" json:"to_update_version,omitempty"`
	CustomTopic       string `protobuf:"bytes,4,opt,name=custom_topic,json=customTopic,proto3" json:"custom_topic,omitempty"`
}

func (m *MissingK8SMetadataRequest) Reset()      { *m = MissingK8SMetadataRequest{} }
func (*MissingK8SMetadataRequest) ProtoMessage() {}
func (*MissingK8SMetadataRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{48}
}
func (m *MissingK8SMetadataRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MissingK8SMetadataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MissingK8SMetadataRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MissingK8SMetadataRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MissingK8SMetadataRequest.Merge(m, src)
}
func (m *MissingK8SMetadataRequest) XXX_Size() int {
	return m.Size()
}
func (m *MissingK8SMetadataRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_MissingK8SMetadataRequest.DiscardUnknown(m)
}

var xxx_messageInfo_MissingK8SMetadataRequest proto.InternalMessageInfo

func (m *MissingK8SMetadataRequest) GetSelector() string {
	if m != nil {
		return m.Selector
	}
	return ""
}

func (m *MissingK8SMetadataRequest) GetFromUpdateVersion() int64 {
	if m != nil {
		return m.FromUpdateVersion
	}
	return 0
}

func (m *MissingK8SMetadataRequest) GetToUpdateVersion() int64 {
	if m != nil {
		return m.ToUpdateVersion
	}
	return 0
}

func (m *MissingK8SMetadataRequest) GetCustomTopic() string {
	if m != nil {
		return m.CustomTopic
	}
	return ""
}

type MissingK8SMetadataResponse struct {
	Updates              []*ResourceUpdate `protobuf:"bytes,1,rep,name=updates,proto3" json:"updates,omitempty"`
	FirstUpdateAvailable int64             `protobuf:"varint,2,opt,name=first_update_available,json=firstUpdateAvailable,proto3" json:"first_update_available,omitempty"`
	LastUpdateAvailable  int64             `protobuf:"varint,3,opt,name=last_update_available,json=lastUpdateAvailable,proto3" json:"last_update_available,omitempty"`
}

func (m *MissingK8SMetadataResponse) Reset()      { *m = MissingK8SMetadataResponse{} }
func (*MissingK8SMetadataResponse) ProtoMessage() {}
func (*MissingK8SMetadataResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_281217845a4326db, []int{49}
}
func (m *MissingK8SMetadataResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MissingK8SMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MissingK8SMetadataResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MissingK8SMetadataResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MissingK8SMetadataResponse.Merge(m, src)
}
func (m *MissingK8SMetadataResponse) XXX_Size() int {
	return m.Size()
}
func (m *MissingK8SMetadataResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MissingK8SMetadataResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MissingK8SMetadataResponse proto.InternalMessageInfo

func (m *MissingK8SMetadataResponse) GetUpdates() []*ResourceUpdate {
	if m != nil {
		return m.Updates
	}
	return nil
}

func (m *MissingK8SMetadataResponse) GetFirstUpdateAvailable() int64 {
	if m != nil {
		return m.FirstUpdateAvailable
	}
	return 0
}

func (m *MissingK8SMetadataResponse) GetLastUpdateAvailable() int64 {
	if m != nil {
		return m.LastUpdateAvailable
	}
	return 0
}

func init() {
	proto.RegisterEnum("px.shared.k8s.metadatapb.DNSPolicy", DNSPolicy_name, DNSPolicy_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.PodPhase", PodPhase_name, PodPhase_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.PodQOSClass", PodQOSClass_name, PodQOSClass_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.ContainerState", ContainerState_name, ContainerState_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.PodConditionType", PodConditionType_name, PodConditionType_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.IPProtocol", IPProtocol_name, IPProtocol_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.ServiceType", ServiceType_name, ServiceType_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.ExternalTrafficPolicyType", ExternalTrafficPolicyType_name, ExternalTrafficPolicyType_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.ContainerType", ContainerType_name, ContainerType_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.NodePhase", NodePhase_name, NodePhase_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.NodeAddressType", NodeAddressType_name, NodeAddressType_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.ConditionStatus", ConditionStatus_name, ConditionStatus_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.NodeConditionType", NodeConditionType_name, NodeConditionType_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.DeploymentConditionType", DeploymentConditionType_name, DeploymentConditionType_value)
	proto.RegisterEnum("px.shared.k8s.metadatapb.DeploymentStrategyType", DeploymentStrategyType_name, DeploymentStrategyType_value)
	proto.RegisterType((*MetadataObject)(nil), "px.shared.k8s.metadatapb.MetadataObject")
	proto.RegisterType((*ObjectMetadata)(nil), "px.shared.k8s.metadatapb.ObjectMetadata")
	proto.RegisterMapType((map[string]string)(nil), "px.shared.k8s.metadatapb.ObjectMetadata.AnnotationsEntry")
	proto.RegisterMapType((map[string]string)(nil), "px.shared.k8s.metadatapb.ObjectMetadata.LabelsEntry")
	proto.RegisterType((*OwnerReference)(nil), "px.shared.k8s.metadatapb.OwnerReference")
	proto.RegisterType((*Namespace)(nil), "px.shared.k8s.metadatapb.Namespace")
	proto.RegisterType((*Pod)(nil), "px.shared.k8s.metadatapb.Pod")
	proto.RegisterType((*PodSpec)(nil), "px.shared.k8s.metadatapb.PodSpec")
	proto.RegisterMapType((map[string]string)(nil), "px.shared.k8s.metadatapb.PodSpec.NodeSelectorEntry")
	proto.RegisterType((*ContainerStatus)(nil), "px.shared.k8s.metadatapb.ContainerStatus")
	proto.RegisterType((*K8SEvent)(nil), "px.shared.k8s.metadatapb.K8sEvent")
	proto.RegisterType((*PodStatus)(nil), "px.shared.k8s.metadatapb.PodStatus")
	proto.RegisterType((*PodCondition)(nil), "px.shared.k8s.metadatapb.PodCondition")
	proto.RegisterType((*Endpoints)(nil), "px.shared.k8s.metadatapb.Endpoints")
	proto.RegisterType((*EndpointSubset)(nil), "px.shared.k8s.metadatapb.EndpointSubset")
	proto.RegisterType((*EndpointAddress)(nil), "px.shared.k8s.metadatapb.EndpointAddress")
	proto.RegisterType((*EndpointPort)(nil), "px.shared.k8s.metadatapb.EndpointPort")
	proto.RegisterType((*ObjectReference)(nil), "px.shared.k8s.metadatapb.ObjectReference")
	proto.RegisterType((*Service)(nil), "px.shared.k8s.metadatapb.Service")
	proto.RegisterType((*ServiceSpec)(nil), "px.shared.k8s.metadatapb.ServiceSpec")
	proto.RegisterType((*ServicePort)(nil), "px.shared.k8s.metadatapb.ServicePort")
	proto.RegisterType((*ContainerInfo)(nil), "px.shared.k8s.metadatapb.ContainerInfo")
	proto.RegisterType((*ProcessInfo)(nil), "px.shared.k8s.metadatapb.ProcessInfo")
	proto.RegisterType((*PodUpdate)(nil), "px.shared.k8s.metadatapb.PodUpdate")
	proto.RegisterType((*ContainerUpdate)(nil), "px.shared.k8s.metadatapb.ContainerUpdate")
	proto.RegisterType((*ServiceUpdate)(nil), "px.shared.k8s.metadatapb.ServiceUpdate")
	proto.RegisterType((*NamespaceUpdate)(nil), "px.shared.k8s.metadatapb.NamespaceUpdate")
	proto.RegisterType((*ProcessCreated)(nil), "px.shared.k8s.metadatapb.ProcessCreated")
	proto.RegisterType((*ProcessTerminated)(nil), "px.shared.k8s.metadatapb.ProcessTerminated")
	proto.RegisterType((*Node)(nil), "px.shared.k8s.metadatapb.Node")
	proto.RegisterType((*NodeSpec)(nil), "px.shared.k8s.metadatapb.NodeSpec")
	proto.RegisterType((*NodeAddress)(nil), "px.shared.k8s.metadatapb.NodeAddress")
	proto.RegisterType((*NodeCondition)(nil), "px.shared.k8s.metadatapb.NodeCondition")
	proto.RegisterType((*NodeStatus)(nil), "px.shared.k8s.metadatapb.NodeStatus")
	proto.RegisterType((*NodeUpdate)(nil), "px.shared.k8s.metadatapb.NodeUpdate")
	proto.RegisterType((*ReplicaSet)(nil), "px.shared.k8s.metadatapb.ReplicaSet")
	proto.RegisterType((*ReplicaSetCondition)(nil), "px.shared.k8s.metadatapb.ReplicaSetCondition")
	proto.RegisterType((*LabelSelectorRequirement)(nil), "px.shared.k8s.metadatapb.LabelSelectorRequirement")
	proto.RegisterType((*LabelSelector)(nil), "px.shared.k8s.metadatapb.LabelSelector")
	proto.RegisterMapType((map[string]string)(nil), "px.shared.k8s.metadatapb.LabelSelector.MatchLabelsEntry")
	proto.RegisterType((*PodTemplateSpec)(nil), "px.shared.k8s.metadatapb.PodTemplateSpec")
	proto.RegisterType((*ReplicaSetSpec)(nil), "px.shared.k8s.metadatapb.ReplicaSetSpec")
	proto.RegisterType((*ReplicaSetStatus)(nil), "px.shared.k8s.metadatapb.ReplicaSetStatus")
	proto.RegisterType((*ReplicaSetUpdate)(nil), "px.shared.k8s.metadatapb.ReplicaSetUpdate")
	proto.RegisterType((*Deployment)(nil), "px.shared.k8s.metadatapb.Deployment")
	proto.RegisterType((*DeploymentCondition)(nil), "px.shared.k8s.metadatapb.DeploymentCondition")
	proto.RegisterType((*DeploymentStatus)(nil), "px.shared.k8s.metadatapb.DeploymentStatus")
	proto.RegisterType((*DeploymentSpec)(nil), "px.shared.k8s.metadatapb.DeploymentSpec")
	proto.RegisterType((*DeploymentStrategy)(nil), "px.shared.k8s.metadatapb.DeploymentStrategy")
	proto.RegisterType((*RollingUpdateDeployment)(nil), "px.shared.k8s.metadatapb.RollingUpdateDeployment")
	proto.RegisterType((*DeploymentUpdate)(nil), "px.shared.k8s.metadatapb.DeploymentUpdate")
	proto.RegisterType((*ResourceUpdate)(nil), "px.shared.k8s.metadatapb.ResourceUpdate")
	proto.RegisterType((*MissingK8SMetadataRequest)(nil), "px.shared.k8s.metadatapb.MissingK8sMetadataRequest")
	proto.RegisterType((*MissingK8SMetadataResponse)(nil), "px.shared.k8s.metadatapb.MissingK8sMetadataResponse")
}

func init() {
	proto.RegisterFile("src/shared/k8s/metadatapb/metadata.proto", fileDescriptor_281217845a4326db)
}

var fileDescriptor_281217845a4326db = []byte{
	// 4464 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x7b, 0x4f, 0x8c, 0x1b, 0x59,
	0x5a, 0x78, 0x97, 0xff, 0xfb, 0x73, 0xb7, 0xbb, 0xfa, 0x75, 0x27, 0x71, 0x3a, 0xb3, 0xdd, 0x49,
	0x25, 0x99, 0x49, 0xfa, 0xb7, 0xd3, 0xf9, 0x4d, 0x76, 0x16, 0x92, 0xd9, 0xd9, 0x99, 0x75, 0xdb,
	0x95, 0x74, 0x25, 0x8e, 0xed, 0x3c, 0xdb, 0x99, 0xc9, 0xac, 0x50, 0x51, 0xed, 0xaa, 0xee, 0x14,
	0xb1, 0xab, 0x6a, 0xaa, 0xca, 0x21, 0x2d, 0x21, 0x84, 0x84, 0x56, 0x20, 0x10, 0x68, 0x11, 0x8b,
	0x40, 0xc0, 0x8d, 0x0b, 0x07, 0x0e, 0x1c, 0x56, 0x80, 0xb8, 0x80, 0x90, 0x56, 0x42, 0xc0, 0x61,
	0x0e, 0x8b, 0x34, 0xa7, 0x16, 0xe3, 0x41, 0x82, 0xe3, 0x0a, 0x89, 0x3b, 0x7a, 0xef, 0xd5, 0xff,
	0xb6, 0xdd, 0xee, 0x24, 0x03, 0xd9, 0xbd, 0x24, 0x7e, 0xef, 0xfb, 0x53, 0xdf, 0xfb, 0xfe, 0xbd,
	0xef, 0x7b, 0xef, 0x35, 0x5c, 0x73, 0xec, 0xfe, 0x0d, 0xe7, 0x89, 0x62, 0x6b, 0xea, 0x8d, 0xa7,
	0xb7, 0x9c, 0x1b, 0x43, 0xcd, 0x55, 0x54, 0xc5, 0x55, 0xac, 0xbd, 0xe0, 0xe7, 0xb6, 0x65, 0x9b,
	0xae, 0x89, 0x2a, 0xd6, 0xf3, 0x6d, 0x86, 0xb8, 0xfd, 0xf4, 0x96, 0xb3, 0x1d, 0x22, 0xae, 0xbf,
	0x7d, 0xa0, 0xbb, 0x4f, 0x46, 0x7b, 0xdb, 0x7d, 0x73, 0x78, 0xe3, 0xc0, 0x3c, 0x30, 0x6f, 0x50,
	0x82, 0xbd, 0xd1, 0x3e, 0x1d, 0xd1, 0x01, 0xfd, 0xc5, 0x18, 0xad, 0x6f, 0x1e, 0x98, 0xe6, 0xc1,
	0x40, 0x0b, 0xb1, 0x5c, 0x7d, 0xa8, 0x39, 0xae, 0x32, 0xb4, 0x3c, 0x84, 0x2b, 0x11, 0x99, 0xdc,
	0x43, 0x4b, 0x73, 0xd8, 0xbf, 0xd6, 0x1e, 0xfb, 0x9f, 0x61, 0x09, 0x3f, 0x48, 0x43, 0xf9, 0x81,
	0x27, 0x44, 0x6b, 0xef, 0x97, 0xb4, 0xbe, 0x8b, 0xde, 0x81, 0xb4, 0x65, 0xaa, 0x15, 0xee, 0x22,
	0x77, 0xad, 0x74, 0xf3, 0x6b, 0xdb, 0xd3, 0x04, 0xde, 0x6e, 0x9b, 0xea, 0xee, 0x02, 0x26, 0xb8,
	0xa8, 0x06, 0x45, 0xcd, 0x50, 0x2d, 0x53, 0x37, 0x5c, 0xa7, 0x92, 0xa2, 0x84, 0x97, 0xa7, 0x13,
	0x8a, 0x3e, 0xea, 0xee, 0x02, 0x0e, 0xe9, 0xd0, 0xb7, 0x21, 0xef, 0x68, 0xf6, 0x33, 0xbd, 0xaf,
	0x55, 0xd2, 0x94, 0xc5, 0xa5, 0xe9, 0x2c, 0x3a, 0x0c, 0x71, 0x77, 0x01, 0xfb, 0x34, 0x44, 0x06,
	0x43, 0x19, 0x6a, 0x8e, 0xa5, 0xf4, 0xb5, 0x4a, 0xe6, 0x24, 0x19, 0x9a, 0x3e, 0x2a, 0x91, 0x21,
	0xa0, 0x43, 0xef, 0x42, 0xc6, 0x30, 0x55, 0xad, 0x92, 0xa5, 0xf4, 0x1b, 0x33, 0xe8, 0x4d, 0x95,
	0x90, 0x52, 0x6c, 0x74, 0x07, 0xc0, 0xd6, 0xac, 0x81, 0xde, 0x57, 0x3a, 0x9a, 0x5b, 0xc9, 0x51,
	0xda, 0x2b, 0xd3, 0x69, 0x71, 0x80, 0xbb, 0xbb, 0x80, 0x23, 0x94, 0x3b, 0x05, 0xc8, 0x99, 0xd4,
	0x06, 0xc2, 0x9f, 0x65, 0xa1, 0xcc, 0xcc, 0xe1, 0x1b, 0x07, 0x21, 0xc8, 0x10, 0x39, 0xa9, 0x5d,
	0x8a, 0x98, 0xfe, 0x46, 0x6f, 0x44, 0xd7, 0x9c, 0xa2, 0x80, 0xc8, 0x62, 0xce, 0x43, 0x7a, 0xa4,
	0xab, 0x54, 0x99, 0xc5, 0x9d, 0xfc, 0xf8, 0x68, 0x33, 0xdd, 0x93, 0xea, 0x98, 0xcc, 0xa1, 0xeb,
	0xc0, 0xdb, 0x9a, 0x63, 0x8e, 0xec, 0xbe, 0x26, 0x3f, 0xd3, 0x6c, 0x47, 0x37, 0x0d, 0xaa, 0xb3,
	0x22, 0x5e, 0xf6, 0xe7, 0x1f, 0xb1, 0x69, 0x74, 0x1f, 0xce, 0xf4, 0x6d, 0x4d, 0x71, 0x75, 0xd3,
	0x90, 0x03, 0x1f, 0x93, 0x0d, 0x87, 0xea, 0x28, 0xbd, 0x73, 0x6e, 0x7c, 0xb4, 0xb9, 0x5a, 0xf3,
	0x10, 0xba, 0x3e, 0xbc, 0xd9, 0xc1, 0xab, 0xfd, 0x63, 0x93, 0x0e, 0x61, 0xa6, 0x6a, 0x03, 0xed,
	0x38, 0xb3, 0x5c, 0xc8, 0xac, 0xee, 0x21, 0xc4, 0x98, 0xa9, 0xc7, 0x26, 0x1d, 0xd4, 0x80, 0xdc,
	0x40, 0xd9, 0xd3, 0x06, 0x4e, 0x25, 0x7f, 0x31, 0x7d, 0xad, 0x74, 0xf3, 0xdd, 0xe9, 0x2a, 0x8f,
	0xeb, 0x72, 0xbb, 0x41, 0xc9, 0x44, 0xc3, 0xb5, 0x0f, 0xb1, 0xc7, 0x03, 0x75, 0x80, 0x37, 0x7f,
	0xd9, 0xd0, 0x6c, 0xd9, 0xd6, 0xf6, 0x35, 0x5b, 0x33, 0xfa, 0x9a, 0x53, 0x29, 0x50, 0xbe, 0xd7,
	0x66, 0xf0, 0x25, 0x14, 0xd8, 0x27, 0xc0, 0xcb, 0x66, 0x6c, 0xec, 0xa0, 0xef, 0x42, 0x49, 0x31,
	0x0c, 0xd3, 0xa5, 0x8a, 0x70, 0x2a, 0x40, 0xf9, 0xdd, 0x9e, 0x5b, 0xce, 0x6a, 0x48, 0xcb, 0x84,
	0x8d, 0x72, 0x5b, 0xbf, 0x0d, 0xa5, 0xc8, 0x42, 0x10, 0x0f, 0xe9, 0xa7, 0xda, 0xa1, 0xe7, 0x1f,
	0xe4, 0x27, 0x5a, 0x83, 0xec, 0x33, 0x65, 0x30, 0xf2, 0x5d, 0x83, 0x0d, 0xde, 0x4b, 0xdd, 0xe2,
	0xd6, 0x3f, 0x00, 0x3e, 0xc9, 0xfb, 0x34, 0xf4, 0xf7, 0x32, 0x85, 0x22, 0x0f, 0x42, 0x07, 0xca,
	0x71, 0x05, 0x10, 0x27, 0x7d, 0xaa, 0x1b, 0xaa, 0xef, 0xa4, 0xe4, 0x77, 0xe0, 0xb8, 0xe9, 0x88,
	0xe3, 0x7a, 0xae, 0x99, 0x39, 0xee, 0x9a, 0xc2, 0x43, 0x28, 0x06, 0xc1, 0x89, 0xea, 0x50, 0xf0,
	0xb5, 0xe3, 0x25, 0xa4, 0x6b, 0xf3, 0x2a, 0x0f, 0x07, 0x94, 0xc2, 0xdf, 0x71, 0x90, 0x6e, 0x9b,
	0xea, 0xab, 0xe1, 0x86, 0xbe, 0x09, 0x19, 0xc7, 0xd2, 0xfa, 0x5e, 0x9e, 0xbb, 0x34, 0x33, 0x41,
	0x76, 0x2c, 0xad, 0x8f, 0x29, 0x3a, 0xfa, 0x16, 0xe4, 0x1c, 0x57, 0x71, 0x47, 0x8e, 0x97, 0xdd,
	0x2e, 0xcf, 0x26, 0xa4, 0xa8, 0xd8, 0x23, 0x11, 0xfe, 0x38, 0x0d, 0x79, 0x8f, 0x1d, 0x7a, 0x08,
	0xa0, 0x1a, 0x8e, 0x6c, 0x99, 0x03, 0xbd, 0xcf, 0xcc, 0x55, 0x9e, 0xc5, 0xac, 0xde, 0xec, 0xb4,
	0x29, 0xea, 0xce, 0xd2, 0xf8, 0x68, 0xb3, 0x18, 0x0c, 0x71, 0x51, 0x35, 0x1c, 0xf6, 0x13, 0x7d,
	0x0c, 0x4b, 0x24, 0x91, 0xc9, 0x8e, 0x36, 0xd0, 0xfa, 0xae, 0x69, 0x57, 0x52, 0xd4, 0x51, 0xbf,
	0x71, 0xe2, 0xda, 0x68, 0x1e, 0xec, 0x78, 0x54, 0xcc, 0x45, 0x17, 0x8d, 0xc8, 0x14, 0xba, 0x00,
	0x45, 0xca, 0x39, 0xe2, 0x01, 0x05, 0x32, 0x41, 0x4c, 0x8c, 0xd6, 0xa1, 0xf0, 0xc4, 0x74, 0x5c,
	0x0a, 0x63, 0xd9, 0x27, 0x18, 0x93, 0xd4, 0xe6, 0x8c, 0xf6, 0x54, 0x73, 0xa8, 0xe8, 0x06, 0x4d,
	0x35, 0x45, 0x1c, 0x4e, 0xa0, 0x6d, 0x58, 0xb5, 0x6c, 0xdd, 0xb4, 0x75, 0xf7, 0x50, 0xee, 0x0f,
	0x14, 0xc7, 0x61, 0x1f, 0xc8, 0x51, 0xbc, 0x15, 0x1f, 0x54, 0x23, 0x10, 0xff, 0x4b, 0xfe, 0x64,
	0x25, 0x7f, 0x91, 0xbb, 0x96, 0xc5, 0xc1, 0x78, 0xfd, 0x43, 0x58, 0x39, 0xb6, 0x8a, 0xd3, 0x04,
	0x83, 0xf0, 0x9b, 0x69, 0x58, 0xae, 0x99, 0x86, 0xab, 0xe8, 0x86, 0x66, 0x33, 0xc3, 0x4d, 0xcc,
	0xd6, 0x37, 0x61, 0xb1, 0xef, 0xa3, 0xc9, 0xba, 0xca, 0x18, 0xed, 0x2c, 0x8f, 0x8f, 0x36, 0x4b,
	0x01, 0xb9, 0x54, 0xc7, 0xa5, 0x00, 0x49, 0x52, 0xd1, 0x43, 0x58, 0x0e, 0x69, 0x88, 0x33, 0x30,
	0x2d, 0x96, 0x67, 0x79, 0x6e, 0x4c, 0x16, 0x0d, 0x97, 0xfb, 0xb1, 0x31, 0xda, 0x01, 0xe4, 0xb8,
	0x8a, 0xed, 0xc6, 0x13, 0x70, 0x86, 0x26, 0xe0, 0xb5, 0xf1, 0xd1, 0x26, 0xdf, 0x21, 0xd0, 0x68,
	0xf6, 0xe5, 0x9d, 0xf8, 0x8c, 0x83, 0x3e, 0x84, 0x15, 0xc7, 0x35, 0xad, 0x49, 0x1b, 0xc2, 0xea,
	0xf8, 0x68, 0x73, 0xb9, 0xe3, 0x9a, 0x56, 0x94, 0xc3, 0xb2, 0x13, 0x9b, 0x70, 0x50, 0x05, 0xf2,
	0x43, 0xcd, 0x71, 0x94, 0x03, 0xdf, 0x68, 0xfe, 0x10, 0x9d, 0x85, 0x9c, 0xad, 0x29, 0x8e, 0x69,
	0x50, 0x43, 0x15, 0xb1, 0x37, 0x42, 0x97, 0x61, 0xc9, 0xd6, 0x98, 0xe0, 0x7d, 0x73, 0x64, 0xb8,
	0x95, 0x02, 0xf9, 0x1c, 0x5e, 0xf4, 0x26, 0x6b, 0x64, 0x4e, 0xf8, 0x23, 0x0e, 0x0a, 0xf7, 0x6f,
	0x39, 0xe2, 0x33, 0xcd, 0x70, 0xa3, 0xdf, 0xe0, 0xe2, 0xdf, 0xb8, 0x0d, 0xb0, 0xaf, 0xdb, 0x0e,
	0x53, 0x81, 0x17, 0xc8, 0xeb, 0xdb, 0xac, 0xa2, 0xda, 0xf6, 0x2b, 0xaa, 0xed, 0x40, 0x5e, 0x5c,
	0xa4, 0xd8, 0x64, 0x8c, 0x7e, 0x1e, 0x8a, 0x03, 0xc5, 0xa7, 0x4c, 0x9f, 0x48, 0x59, 0x20, 0xc8,
	0x64, 0x28, 0xfc, 0x38, 0x03, 0xc5, 0x20, 0xb0, 0xd1, 0x2d, 0xc8, 0x5a, 0x4f, 0x14, 0x47, 0xf3,
	0xe2, 0x57, 0x98, 0x19, 0x69, 0x6d, 0x82, 0x89, 0x19, 0x01, 0x29, 0x36, 0xfa, 0xa6, 0xa1, 0xea,
	0x6c, 0x47, 0x29, 0xd2, 0x40, 0x7d, 0x73, 0x26, 0x79, 0xcd, 0x47, 0xc7, 0x11, 0xca, 0xa8, 0x76,
	0xd2, 0xd3, 0x2c, 0x90, 0x49, 0x58, 0x20, 0x4f, 0xc2, 0x53, 0xd6, 0x2d, 0x16, 0x90, 0x3b, 0x30,
	0x3e, 0xda, 0xcc, 0xed, 0x9a, 0x8e, 0x2b, 0xb5, 0x71, 0x8e, 0x80, 0x24, 0x0b, 0x5d, 0x84, 0x9c,
	0x65, 0xaa, 0x04, 0x87, 0xda, 0x75, 0xa7, 0x38, 0x3e, 0xda, 0xcc, 0xb6, 0x4d, 0x55, 0x6a, 0xe3,
	0xac, 0x65, 0xaa, 0x92, 0x85, 0xda, 0x50, 0xfc, 0xd4, 0x74, 0x58, 0xd8, 0x52, 0x1b, 0x97, 0x6f,
	0x5e, 0x9d, 0x29, 0xff, 0xc3, 0x56, 0x87, 0x46, 0xf2, 0xce, 0xe2, 0xf8, 0x68, 0xb3, 0xe0, 0x8f,
	0x70, 0xe1, 0x53, 0xd3, 0xa1, 0xbf, 0xd0, 0xc7, 0x80, 0xe2, 0x41, 0x32, 0x72, 0x82, 0xcd, 0xfb,
	0xfa, 0x9c, 0x71, 0x32, 0x72, 0xf0, 0x4a, 0x3f, 0x3e, 0xa1, 0x39, 0xc4, 0x51, 0x68, 0x19, 0xa3,
	0xa9, 0xb2, 0xe2, 0x56, 0x4a, 0x27, 0x3b, 0x8a, 0x87, 0x5d, 0x75, 0xd1, 0x7b, 0x90, 0xd3, 0x88,
	0x1b, 0x3a, 0x95, 0x45, 0x2a, 0xc8, 0x0c, 0x13, 0xfb, 0x1e, 0x8b, 0x3d, 0x8a, 0xe3, 0xbe, 0xbe,
	0x74, 0xdc, 0xd7, 0xef, 0x65, 0x0a, 0x29, 0x3e, 0x2d, 0xfc, 0x1e, 0x07, 0x8b, 0x51, 0x1b, 0xa3,
	0x0f, 0x20, 0x43, 0x0a, 0x7c, 0xcf, 0xb1, 0xb6, 0xe6, 0xf3, 0x8c, 0xee, 0xa1, 0xa5, 0x61, 0x4a,
	0x87, 0xaa, 0xc1, 0x3e, 0x95, 0xa2, 0x1c, 0x66, 0x2b, 0x90, 0x91, 0x27, 0x76, 0xab, 0x3f, 0xe0,
	0xa0, 0x18, 0x14, 0xf9, 0xaf, 0x68, 0xd7, 0xdd, 0x81, 0xbc, 0x33, 0xda, 0x73, 0x34, 0xda, 0x60,
	0x9c, 0x50, 0x95, 0xf9, 0xdf, 0xee, 0x50, 0x02, 0xec, 0x13, 0x0a, 0xff, 0xc5, 0x41, 0x39, 0x0e,
	0x43, 0x77, 0xa1, 0xa8, 0xa8, 0xaa, 0xad, 0x39, 0xc4, 0x63, 0xb8, 0x93, 0x3c, 0xc6, 0x27, 0xae,
	0x32, 0x12, 0x1c, 0xd2, 0xa2, 0xc7, 0xb0, 0x6a, 0x98, 0xae, 0x6c, 0x6b, 0x8a, 0x7a, 0x28, 0x87,
	0x2c, 0x53, 0xa7, 0x65, 0xb9, 0x62, 0x98, 0x2e, 0x26, 0x4c, 0xaa, 0x01, 0xeb, 0xf7, 0x21, 0x6b,
	0x99, 0xb6, 0x4b, 0x0a, 0x87, 0x13, 0x82, 0xdd, 0x67, 0xd6, 0x36, 0x6d, 0x17, 0x33, 0x22, 0xe1,
	0x2f, 0x38, 0x58, 0x4e, 0x7c, 0x04, 0x9d, 0x85, 0x94, 0x6e, 0xb1, 0xa4, 0xb8, 0x93, 0x1b, 0x1f,
	0x6d, 0xa6, 0xa4, 0x36, 0x4e, 0xe9, 0x56, 0x6c, 0x43, 0x4e, 0x25, 0x36, 0xe4, 0x99, 0x3b, 0xf9,
	0x2e, 0x80, 0xab, 0xd8, 0x07, 0x1a, 0x51, 0xc0, 0xbe, 0xd7, 0x7d, 0x5d, 0x3f, 0xc9, 0xca, 0x61,
	0xdd, 0x5c, 0x64, 0xc4, 0x58, 0xdb, 0x17, 0x9e, 0xc3, 0x62, 0x74, 0x15, 0x13, 0x37, 0x52, 0x04,
	0x19, 0xb2, 0x36, 0x2a, 0x62, 0x16, 0xd3, 0xdf, 0xe8, 0x3b, 0x64, 0x87, 0x37, 0x5d, 0xb3, 0x6f,
	0x0e, 0xbc, 0x1d, 0x72, 0x46, 0x07, 0x26, 0xb5, 0xdb, 0x1e, 0x2e, 0x0e, 0xa8, 0x84, 0x3f, 0xe5,
	0x60, 0x39, 0x21, 0xd8, 0xc4, 0x7a, 0x76, 0x76, 0xd3, 0x75, 0xba, 0x6a, 0x17, 0x5d, 0x83, 0x64,
	0xc3, 0xe5, 0xed, 0x87, 0xc9, 0x69, 0xe1, 0xb7, 0x38, 0xc8, 0x7b, 0x6d, 0xef, 0x2b, 0x0a, 0xa9,
	0xdb, 0xb1, 0x42, 0xf6, 0xea, 0x89, 0xdd, 0x76, 0x58, 0xcc, 0x0a, 0x7f, 0x9d, 0x86, 0x52, 0x64,
	0x16, 0x7d, 0xcb, 0x77, 0x51, 0x16, 0x42, 0x27, 0xf3, 0x8a, 0x78, 0x28, 0xfa, 0x3a, 0x40, 0x7f,
	0x30, 0x72, 0x5c, 0x52, 0x15, 0x59, 0x5e, 0x55, 0x44, 0x6b, 0xd5, 0x1a, 0x9b, 0x95, 0xda, 0xb8,
	0xe8, 0x21, 0x48, 0x16, 0x91, 0x9a, 0xe6, 0xb7, 0xf4, 0x49, 0x3b, 0x87, 0xf7, 0xa5, 0x48, 0x6a,
	0xbb, 0x09, 0x8b, 0xda, 0x73, 0x57, 0xb3, 0x0d, 0x65, 0x20, 0xeb, 0x16, 0xa9, 0x79, 0xd2, 0x7e,
	0x01, 0x26, 0x7a, 0xf3, 0x52, 0xdb, 0xc1, 0x25, 0x1f, 0x49, 0xb2, 0x48, 0xf0, 0xf1, 0x03, 0x53,
	0x51, 0xe5, 0x3d, 0x65, 0xa0, 0x18, 0x7d, 0x26, 0x22, 0xdb, 0xfd, 0xd0, 0xf8, 0x68, 0xb3, 0xdc,
	0x30, 0x15, 0x75, 0xc7, 0x03, 0x49, 0x6d, 0x5c, 0x1e, 0x44, 0xc7, 0x16, 0x49, 0xe4, 0xc1, 0x17,
	0x23, 0x15, 0x6a, 0x20, 0x06, 0x0d, 0x9e, 0xa7, 0x70, 0x2e, 0x40, 0x72, 0x6d, 0x65, 0x7f, 0x5f,
	0xef, 0xfb, 0xd5, 0x3d, 0xdb, 0x1e, 0x67, 0xd4, 0xe1, 0xbe, 0xdc, 0x5d, 0x46, 0xc7, 0xea, 0x79,
	0xba, 0xe4, 0x33, 0xda, 0x24, 0x90, 0xf0, 0x03, 0x2e, 0xb0, 0xdc, 0xd4, 0xf8, 0x8a, 0xc6, 0x52,
	0xea, 0x45, 0x62, 0x29, 0x88, 0xd0, 0x74, 0x24, 0x42, 0xfd, 0x04, 0x42, 0x01, 0x19, 0x56, 0x84,
	0x93, 0x09, 0x22, 0x86, 0xf0, 0xcf, 0x29, 0x58, 0x0a, 0x8b, 0x60, 0x63, 0xdf, 0x9c, 0x28, 0x98,
	0x17, 0x48, 0xa9, 0x09, 0x81, 0x34, 0xb9, 0xaa, 0x4d, 0xbf, 0x7c, 0x55, 0x9b, 0x39, 0x45, 0x55,
	0x7b, 0x19, 0xf2, 0xa4, 0xf8, 0x21, 0x32, 0x46, 0x2a, 0xa4, 0xb6, 0xa9, 0x12, 0x31, 0x49, 0x5d,
	0xd4, 0xd3, 0x13, 0xf9, 0x23, 0x97, 0xcc, 0x1f, 0x35, 0x28, 0x5a, 0xb6, 0xd9, 0x67, 0xbb, 0x47,
	0xfe, 0xa4, 0x68, 0x6a, 0x33, 0x54, 0xa2, 0x30, 0x1c, 0xd2, 0x09, 0x7f, 0x92, 0x82, 0x52, 0x04,
	0x34, 0x51, 0x97, 0x37, 0x20, 0x33, 0xb2, 0x3c, 0x65, 0x96, 0x6e, 0xae, 0x90, 0x6f, 0xb0, 0x83,
	0xc1, 0x9e, 0x64, 0xb8, 0xef, 0xdc, 0xbc, 0xb5, 0x53, 0x18, 0x1f, 0x6d, 0x66, 0x7a, 0x6d, 0xa9,
	0x8e, 0x29, 0xe2, 0xeb, 0xd1, 0x37, 0x5c, 0x82, 0x45, 0x6f, 0x99, 0xb2, 0x62, 0x1f, 0x38, 0x9e,
	0xfe, 0x4a, 0xde, 0x5c, 0xd5, 0x3e, 0x70, 0x88, 0x93, 0xf4, 0x75, 0x95, 0x75, 0x0f, 0xcc, 0x49,
	0x6a, 0xc4, 0x49, 0xfa, 0xba, 0x7a, 0x2f, 0x53, 0x48, 0xf3, 0x19, 0xe1, 0x2f, 0x73, 0xb4, 0x12,
	0xef, 0x59, 0x2a, 0x69, 0x87, 0x3c, 0x9f, 0xe2, 0x26, 0xf8, 0x94, 0xaf, 0xb6, 0xd4, 0xb4, 0x23,
	0xb7, 0x74, 0xd2, 0x7a, 0xaf, 0x85, 0x8e, 0xbe, 0x09, 0x4b, 0xd1, 0x3e, 0x93, 0x28, 0x89, 0xe4,
	0x39, 0x7e, 0x7c, 0xb4, 0xb9, 0x18, 0x69, 0x34, 0x1d, 0xbc, 0x18, 0xe9, 0x34, 0x1d, 0xf4, 0x56,
	0xb4, 0xd5, 0xa4, 0x4b, 0xaa, 0x94, 0x08, 0x61, 0xa4, 0x81, 0xa4, 0x07, 0x33, 0x5f, 0x41, 0x01,
	0x1f, 0x74, 0x43, 0x85, 0x97, 0xeb, 0x86, 0xf8, 0x17, 0xee, 0x86, 0x62, 0xd5, 0x4d, 0x71, 0xc6,
	0x39, 0x05, 0x24, 0xca, 0xa2, 0xb0, 0xdf, 0x59, 0x9c, 0xd2, 0xef, 0x44, 0xda, 0xa6, 0xa5, 0xa9,
	0x6d, 0x53, 0xa4, 0x1b, 0x2b, 0x4f, 0xeb, 0xc6, 0x96, 0x63, 0xdd, 0xd8, 0xd9, 0xe0, 0xf4, 0x73,
	0x85, 0xcd, 0xcf, 0x38, 0xc7, 0x44, 0x2f, 0x79, 0x8e, 0x29, 0xfc, 0x77, 0xf4, 0x88, 0x23, 0x0c,
	0x9c, 0x7e, 0x3c, 0x70, 0xfc, 0x38, 0x9b, 0x18, 0x38, 0xaf, 0x45, 0x82, 0x8e, 0x45, 0x6f, 0x36,
	0x19, 0xbd, 0xbe, 0x2d, 0xd5, 0x64, 0xef, 0x5a, 0x67, 0xb6, 0x54, 0xd1, 0x79, 0x28, 0x10, 0x0c,
	0xba, 0x38, 0x76, 0x3c, 0x41, 0x12, 0x3e, 0x75, 0x92, 0x09, 0x27, 0x35, 0x85, 0x97, 0x3c, 0xa9,
	0x89, 0x38, 0x45, 0x71, 0x9a, 0x53, 0x40, 0xcc, 0x29, 0x9a, 0x10, 0xf2, 0x90, 0x69, 0x99, 0x54,
	0xa2, 0x32, 0xbc, 0x35, 0x87, 0x0c, 0xb4, 0x6a, 0x08, 0x33, 0x07, 0x19, 0x0a, 0xdf, 0x4b, 0xc3,
	0x92, 0x57, 0x2d, 0xfc, 0xcc, 0xa6, 0x4b, 0x6f, 0xd3, 0x0e, 0x13, 0xa5, 0xbf, 0x69, 0x93, 0x14,
	0x99, 0xa3, 0x76, 0xa7, 0xf9, 0xc1, 0x37, 0x3c, 0xdb, 0x96, 0x8b, 0xb8, 0xe0, 0x59, 0xde, 0x39,
	0x56, 0x57, 0x16, 0xe6, 0xa8, 0x2b, 0xe3, 0x45, 0x6f, 0x71, 0x76, 0xd1, 0x2b, 0xfc, 0x88, 0x83,
	0xe5, 0xe0, 0x54, 0xfc, 0xc5, 0x2c, 0xf1, 0x3a, 0xc4, 0x9f, 0xf0, 0xf7, 0x1c, 0x94, 0xbd, 0xc2,
	0xa4, 0xc6, 0x4e, 0x4a, 0x82, 0x3a, 0x84, 0x7b, 0xb9, 0x3a, 0xe4, 0x74, 0x0b, 0xa9, 0x40, 0xbe,
	0x3f, 0x54, 0x07, 0xba, 0xe1, 0x1f, 0x3c, 0xfb, 0x43, 0x3f, 0xab, 0x65, 0x27, 0x56, 0x0f, 0x29,
	0x3e, 0x2d, 0x7c, 0x8f, 0x83, 0x15, 0x6f, 0x09, 0x5d, 0xcd, 0x1e, 0xea, 0xc6, 0x8b, 0xad, 0x62,
	0xa2, 0x2a, 0x53, 0xa7, 0x50, 0xe5, 0x3f, 0x70, 0x90, 0x69, 0x9a, 0xea, 0xab, 0x6a, 0x06, 0x7f,
	0x2e, 0xd6, 0x0c, 0x0a, 0xb3, 0x6f, 0x3e, 0x23, 0xd7, 0x1a, 0xef, 0x27, 0xae, 0x35, 0xae, 0x9c,
	0x40, 0x19, 0x3f, 0x29, 0xfa, 0x05, 0x28, 0xf8, 0xfc, 0xd0, 0x75, 0x16, 0x62, 0x7d, 0x5d, 0xb5,
	0x59, 0x1f, 0x59, 0x64, 0xf5, 0x02, 0xd9, 0xb3, 0xa5, 0x3a, 0x76, 0x68, 0xc0, 0xd5, 0x08, 0x14,
	0xbd, 0xc9, 0xd2, 0x30, 0x41, 0xf5, 0x9a, 0x81, 0xd2, 0xf8, 0x68, 0x33, 0xef, 0x61, 0xd2, 0x9c,
	0x4c, 0x10, 0x85, 0x7d, 0x28, 0x11, 0xf6, 0xfe, 0xb1, 0xc7, 0xb7, 0x63, 0x47, 0x63, 0xd7, 0x67,
	0x4b, 0xea, 0x11, 0x45, 0xda, 0xc7, 0x0a, 0xe4, 0xbd, 0x83, 0x1d, 0x2f, 0xb0, 0xfc, 0xa1, 0xf0,
	0xfb, 0x1c, 0x2c, 0x11, 0x9a, 0xf0, 0x14, 0xee, 0xc3, 0xd8, 0xa7, 0xfe, 0xdf, 0xec, 0x4f, 0x7d,
	0x45, 0xc7, 0x70, 0xff, 0xca, 0x01, 0x84, 0x3a, 0x47, 0xb7, 0xe3, 0x47, 0xce, 0x97, 0x67, 0xcb,
	0x14, 0xab, 0xb2, 0x6a, 0xd1, 0x53, 0xb2, 0xd4, 0x49, 0x4d, 0x49, 0x44, 0x7b, 0xd1, 0x13, 0xb2,
	0xbb, 0xb1, 0x52, 0x8d, 0x9d, 0x65, 0xbd, 0x35, 0xa7, 0x62, 0xa2, 0xb5, 0x9a, 0xf0, 0x87, 0x69,
	0xb6, 0xae, 0x9f, 0xde, 0x3c, 0x18, 0xda, 0x22, 0x7b, 0x6a, 0x5b, 0x44, 0x7d, 0x3f, 0x37, 0xdd,
	0xf7, 0xe3, 0xe1, 0x94, 0x9f, 0x19, 0x4e, 0x71, 0xcb, 0x14, 0x5e, 0xdc, 0x32, 0x3f, 0xe6, 0x00,
	0xc2, 0xd7, 0x0d, 0xaf, 0x28, 0x33, 0xbd, 0x1f, 0xcb, 0x4c, 0xd7, 0xe6, 0x79, 0x57, 0x11, 0xc9,
	0x4f, 0x3b, 0x89, 0xfc, 0xb4, 0x35, 0x17, 0x7d, 0x3c, 0x90, 0x06, 0xb0, 0x1a, 0xc2, 0xc2, 0x18,
	0x47, 0x91, 0x18, 0x2f, 0xbe, 0xba, 0xb0, 0xfd, 0x45, 0xa8, 0xd0, 0x6b, 0x7d, 0xff, 0x42, 0x12,
	0x6b, 0x9f, 0x8e, 0x74, 0x5b, 0x1b, 0x6a, 0x86, 0x3b, 0xe1, 0x5a, 0x72, 0x1d, 0x0a, 0xa6, 0xa5,
	0xd9, 0x0a, 0xbb, 0xb5, 0xa5, 0xbd, 0x89, 0x3f, 0x26, 0x55, 0x22, 0xbd, 0xa5, 0x64, 0xd1, 0x56,
	0xc4, 0xde, 0x48, 0xf8, 0x9d, 0x14, 0x2c, 0xc5, 0x3e, 0x81, 0xbe, 0x0b, 0x8b, 0x43, 0xc5, 0xed,
	0x3f, 0x91, 0xbd, 0x96, 0x82, 0x1d, 0xe3, 0xdd, 0x9a, 0x2e, 0x7c, 0x8c, 0x7c, 0xfb, 0x01, 0xa1,
	0x8d, 0x3e, 0xaa, 0x28, 0x0d, 0xc3, 0x19, 0x24, 0xc3, 0x0a, 0x63, 0xae, 0x3d, 0xb7, 0x48, 0x2e,
	0xa0, 0x5e, 0xc6, 0xb2, 0xc8, 0xcd, 0x39, 0xbf, 0x10, 0xd1, 0x01, 0xe6, 0x29, 0x33, 0x31, 0xe4,
	0xb5, 0xfe, 0x01, 0xf0, 0x49, 0x09, 0x4e, 0x75, 0x81, 0xfb, 0xbb, 0x1c, 0x2c, 0xb7, 0x4d, 0xb5,
	0xab, 0x0d, 0xad, 0x81, 0xe2, 0xb2, 0xdd, 0xe8, 0xff, 0xf2, 0xad, 0x80, 0xf0, 0xef, 0x1c, 0x94,
	0xe3, 0xde, 0x4c, 0xec, 0xec, 0xbd, 0x14, 0x72, 0xa8, 0x3c, 0x59, 0x1c, 0x8c, 0xd1, 0x16, 0xac,
	0x0c, 0x75, 0xc3, 0xbb, 0x7b, 0x70, 0x34, 0x12, 0x90, 0x8e, 0x77, 0xc2, 0xb6, 0x3c, 0xd4, 0x0d,
	0x7a, 0x9d, 0xd0, 0x61, 0xd3, 0xa8, 0x06, 0x85, 0xc8, 0x2d, 0x3f, 0x37, 0x3b, 0xd2, 0xe3, 0x36,
	0x08, 0x08, 0x91, 0x08, 0x05, 0xd7, 0x53, 0x96, 0x17, 0x56, 0xd7, 0x67, 0x2e, 0x2d, 0xaa, 0x59,
	0x1c, 0x90, 0x0a, 0x7f, 0x9b, 0x02, 0x3e, 0x19, 0x74, 0x33, 0x17, 0xfa, 0x2e, 0x9c, 0xdd, 0x1f,
	0x0d, 0x06, 0x87, 0xcc, 0x4d, 0x35, 0x55, 0x0e, 0x30, 0xd9, 0x55, 0xc0, 0x1a, 0x85, 0x36, 0x18,
	0x10, 0xfb, 0x54, 0x57, 0xa1, 0xcc, 0x54, 0x13, 0x60, 0x33, 0xdd, 0x2c, 0xd1, 0xd9, 0x00, 0xed,
	0x6d, 0x40, 0xca, 0x33, 0x45, 0x1f, 0x28, 0x7b, 0x03, 0x2d, 0x44, 0xcd, 0x52, 0xd4, 0x95, 0x00,
	0x12, 0xa0, 0xdf, 0x80, 0x55, 0x73, 0xcf, 0xd1, 0xec, 0x67, 0x9a, 0x2a, 0x1f, 0x68, 0x06, 0x09,
	0x39, 0xdd, 0x34, 0xd8, 0x46, 0x82, 0x91, 0x0f, 0xba, 0x1b, 0x40, 0xd0, 0x83, 0x58, 0x96, 0xcd,
	0x51, 0xff, 0x7f, 0x7b, 0x9e, 0x6c, 0x34, 0x39, 0xd7, 0x7e, 0x3f, 0x1b, 0x55, 0xde, 0x4f, 0xf1,
	0x5e, 0x18, 0x6b, 0x11, 0x17, 0x93, 0x2d, 0x62, 0xd4, 0x1d, 0xb2, 0x73, 0xbb, 0x43, 0xee, 0x54,
	0xee, 0x90, 0x9f, 0xdf, 0x1d, 0x0a, 0xa7, 0x74, 0x87, 0x22, 0xc5, 0x9f, 0xe4, 0x0e, 0x6f, 0x03,
	0xb2, 0xb5, 0x4f, 0x47, 0x9a, 0xe3, 0x46, 0x05, 0x5f, 0x62, 0xfc, 0x03, 0x48, 0xc0, 0x3f, 0xee,
	0x3d, 0xf0, 0x92, 0xde, 0x33, 0xf1, 0x94, 0xa8, 0xf4, 0xb2, 0xa7, 0x44, 0x64, 0xfb, 0xaf, 0x6b,
	0xd6, 0xc0, 0x3c, 0xa4, 0x9b, 0xd5, 0xff, 0xf2, 0xf6, 0x1f, 0x7e, 0xf9, 0xc5, 0xb6, 0xff, 0x08,
	0x7d, 0x7c, 0x43, 0xfe, 0x8f, 0x14, 0xac, 0x86, 0xc0, 0x70, 0xff, 0x17, 0x63, 0x35, 0xfe, 0x3b,
	0xf3, 0x70, 0xfe, 0x6a, 0x2a, 0x7d, 0x54, 0x83, 0x55, 0xfa, 0x28, 0x65, 0x44, 0xb3, 0x00, 0x0d,
	0xc5, 0x44, 0x20, 0x37, 0x14, 0xc7, 0xcb, 0x11, 0x24, 0xf4, 0x48, 0x20, 0x0f, 0xe2, 0x33, 0x0e,
	0x6a, 0xc1, 0x39, 0xf6, 0xb2, 0xc5, 0x56, 0x0c, 0x47, 0x0f, 0x9e, 0x68, 0x86, 0xe1, 0x5c, 0x19,
	0x1f, 0x6d, 0xae, 0x11, 0x46, 0xdd, 0x00, 0xc3, 0x63, 0xb6, 0x36, 0x38, 0x3e, 0xeb, 0x44, 0x0e,
	0xa9, 0xb2, 0xb1, 0x43, 0xaa, 0xa9, 0x6f, 0x7f, 0x84, 0xdf, 0x4e, 0x03, 0x9f, 0x34, 0xc3, 0xb4,
	0xc8, 0xe2, 0xa6, 0x26, 0xda, 0x68, 0xca, 0x48, 0x25, 0x52, 0xc6, 0x75, 0xe0, 0x99, 0x92, 0x22,
	0x31, 0xc7, 0x2e, 0xa9, 0x96, 0xbd, 0xf9, 0xaf, 0x78, 0xdb, 0x78, 0x07, 0xd6, 0x46, 0xc6, 0x04,
	0x02, 0x96, 0xb1, 0x56, 0x23, 0xb0, 0x29, 0xa1, 0x9f, 0x3f, 0x29, 0xf4, 0x27, 0x78, 0x5b, 0x2c,
	0xf4, 0xe9, 0x39, 0xff, 0x60, 0xa0, 0x93, 0xda, 0x29, 0xf2, 0x94, 0x2a, 0x8b, 0xcb, 0xc1, 0x34,
	0x7b, 0x4c, 0xf5, 0x37, 0x69, 0x28, 0xc7, 0x83, 0x6a, 0xe6, 0xe6, 0xfc, 0x1a, 0x55, 0x16, 0x68,
	0x17, 0x0a, 0x8e, 0x6b, 0x2b, 0xae, 0x76, 0x70, 0xe8, 0xbd, 0x46, 0xf8, 0xfa, 0x7c, 0x81, 0xcf,
	0x68, 0x70, 0x40, 0x3d, 0xb9, 0xb6, 0xca, 0x4e, 0xae, 0xad, 0xde, 0x85, 0xb3, 0xb6, 0xf6, 0x8c,
	0x29, 0xf6, 0x89, 0xee, 0xb8, 0xa6, 0x7d, 0x28, 0x0f, 0xf4, 0xa1, 0xee, 0xfa, 0xfb, 0x91, 0x0f,
	0xdd, 0x65, 0xc0, 0x06, 0x81, 0x91, 0x30, 0xb1, 0x94, 0x91, 0xa3, 0xb1, 0x2b, 0xab, 0x02, 0xf6,
	0x46, 0xe8, 0x3d, 0x38, 0x6f, 0xd9, 0xe6, 0x01, 0xa9, 0x72, 0x65, 0x55, 0x53, 0xe8, 0xf1, 0x54,
	0x20, 0x01, 0xdb, 0x57, 0xce, 0xf9, 0x08, 0x75, 0x0f, 0xee, 0x49, 0x22, 0xfc, 0x90, 0x03, 0x74,
	0x7c, 0x59, 0xa8, 0x1e, 0xcb, 0x58, 0xff, 0xff, 0x34, 0x2a, 0x89, 0x24, 0xac, 0x8f, 0xa1, 0x6c,
	0x13, 0x4f, 0x31, 0x0e, 0xbc, 0x84, 0xe3, 0x99, 0x7b, 0x46, 0x06, 0xc4, 0x0c, 0x9f, 0xe5, 0x9b,
	0x90, 0x39, 0x5e, 0xb2, 0xa3, 0x00, 0x41, 0x86, 0x73, 0x53, 0x30, 0x89, 0xd7, 0x0e, 0x95, 0xe7,
	0x72, 0x24, 0x3e, 0xbc, 0xda, 0xbe, 0x3c, 0x54, 0x9e, 0xf7, 0xc2, 0x59, 0x74, 0x01, 0x8a, 0x04,
	0xd1, 0x19, 0xd9, 0x07, 0xc1, 0x23, 0x96, 0xa1, 0xf2, 0xbc, 0x43, 0xc6, 0xc2, 0x97, 0x99, 0x68,
	0x82, 0xf9, 0x59, 0x29, 0x9a, 0x8e, 0x5d, 0x64, 0x4c, 0x49, 0x99, 0xb9, 0xa9, 0xc5, 0x48, 0x34,
	0xae, 0xf3, 0x73, 0xa4, 0xcc, 0xc2, 0xbc, 0x29, 0xb3, 0x38, 0x7f, 0xca, 0x84, 0xd3, 0xa6, 0xcc,
	0xd2, 0xf4, 0x94, 0xf9, 0x52, 0xc5, 0xd5, 0xe2, 0x4b, 0x66, 0x58, 0xe1, 0x47, 0x59, 0xd2, 0xbe,
	0xb1, 0xe7, 0x3b, 0x9e, 0x8f, 0xd5, 0x01, 0xe8, 0xcb, 0x00, 0x16, 0x2f, 0xdc, 0x1c, 0x2f, 0xc0,
	0x19, 0xe1, 0xee, 0x02, 0x2e, 0x5a, 0xc1, 0x5d, 0xf5, 0x23, 0xe0, 0xc3, 0xeb, 0x9d, 0x58, 0xec,
	0xcd, 0xf3, 0xcc, 0x31, 0xe0, 0x18, 0x5e, 0x54, 0x79, 0x7c, 0xdb, 0x50, 0xf6, 0xfe, 0x8c, 0xc6,
	0xe7, 0x9a, 0x3e, 0x29, 0x81, 0xc7, 0x6e, 0x85, 0x76, 0x17, 0xf0, 0x92, 0x13, 0xbb, 0x26, 0x7a,
	0x04, 0x7c, 0xe0, 0x8e, 0x3e, 0xcf, 0xdc, 0x49, 0x92, 0x26, 0x6e, 0x38, 0x88, 0xa4, 0x46, 0xe2,
	0xd2, 0xe3, 0x2e, 0x94, 0xe8, 0x3d, 0xad, 0xc7, 0x32, 0x3f, 0xcf, 0x99, 0x73, 0xc0, 0x0d, 0x8c,
	0xf0, 0xd4, 0xf0, 0x13, 0xe2, 0x21, 0xd4, 0xfc, 0xb2, 0xa3, 0xf9, 0x95, 0x13, 0xf5, 0xc1, 0x39,
	0xcf, 0x88, 0x02, 0xae, 0xbc, 0x9d, 0xec, 0xc2, 0x1e, 0xc3, 0x8a, 0x1a, 0xb8, 0x88, 0xcf, 0xba,
	0x34, 0x7f, 0xfd, 0x19, 0xb2, 0x56, 0x93, 0xb9, 0xea, 0x2a, 0x94, 0xbd, 0x22, 0xcf, 0xff, 0xb3,
	0x1d, 0xf6, 0x0c, 0x7a, 0x89, 0xcd, 0xfa, 0x7f, 0xb4, 0x43, 0xdf, 0xc7, 0x6b, 0xcf, 0xe4, 0x04,
	0x6e, 0x91, 0xe2, 0xae, 0x10, 0x50, 0x2f, 0x8a, 0xbf, 0x53, 0x80, 0x1c, 0x43, 0xbd, 0x97, 0x29,
	0x64, 0xf8, 0xec, 0xbd, 0x4c, 0x21, 0xcb, 0xe7, 0x84, 0xbf, 0xe2, 0xe0, 0xfc, 0x03, 0xdd, 0x71,
	0x74, 0xe3, 0xe0, 0xfe, 0x2d, 0x27, 0xa8, 0xcd, 0x59, 0xf8, 0x90, 0x9c, 0x11, 0xec, 0xf7, 0x2c,
	0x15, 0x87, 0xdb, 0xf8, 0x36, 0xac, 0xee, 0xdb, 0xe6, 0x30, 0xf9, 0x7d, 0xd6, 0x1c, 0xaf, 0x10,
	0x50, 0xec, 0xfb, 0x64, 0x97, 0x75, 0xcd, 0x24, 0x36, 0xbd, 0x0d, 0xc1, 0xcb, 0xae, 0x19, 0xc7,
	0xbd, 0x04, 0x8b, 0xfd, 0x91, 0xe3, 0x9a, 0x43, 0xd9, 0x35, 0x2d, 0xbd, 0xef, 0x5d, 0xe0, 0x94,
	0xd8, 0x5c, 0x97, 0x4c, 0x09, 0xff, 0xc4, 0xc1, 0xfa, 0x24, 0xc1, 0x1d, 0xcb, 0x34, 0x1c, 0x92,
	0xc1, 0xf3, 0xec, 0x53, 0xfe, 0x41, 0xd7, 0xcc, 0x43, 0xc5, 0x68, 0x1c, 0x63, 0x9f, 0x90, 0xf6,
	0x9e, 0xf4, 0x09, 0xb9, 0x27, 0x74, 0xb8, 0x2d, 0x31, 0xb1, 0xd7, 0x28, 0x94, 0x51, 0x55, 0x83,
	0xcd, 0xe9, 0x26, 0x9c, 0x89, 0x16, 0xea, 0x21, 0x11, 0xd3, 0xcc, 0x6a, 0x58, 0x94, 0x07, 0x34,
	0x5b, 0x8f, 0x20, 0xfc, 0xa3, 0x0d, 0x54, 0x82, 0x7c, 0x5d, 0xbc, 0x53, 0xed, 0x35, 0xba, 0xfc,
	0x02, 0x2a, 0x40, 0xa6, 0xd9, 0x6a, 0x8a, 0x3c, 0x87, 0x56, 0x60, 0xa9, 0xd6, 0xe8, 0x75, 0xba,
	0x22, 0x96, 0xef, 0x48, 0xb8, 0xd3, 0xe5, 0x53, 0x68, 0x13, 0x2e, 0xc4, 0xa6, 0xe4, 0x8f, 0xa4,
	0xee, 0xae, 0xbc, 0xdb, 0xea, 0x74, 0xe5, 0xa6, 0xd8, 0xe5, 0xd3, 0x5b, 0x7b, 0x50, 0xf0, 0x5f,
	0x53, 0x10, 0xfa, 0xf6, 0x6e, 0xb5, 0x23, 0xca, 0xbd, 0xe6, 0xfd, 0x66, 0xeb, 0xa3, 0x26, 0xbf,
	0x40, 0xbe, 0xd4, 0x16, 0x9b, 0x75, 0xa9, 0x79, 0x97, 0xe7, 0xc8, 0x00, 0xf7, 0x9a, 0x4d, 0x32,
	0x48, 0xa1, 0x25, 0x28, 0x76, 0x7a, 0xb5, 0x9a, 0x28, 0xd6, 0xc5, 0x3a, 0x9f, 0x46, 0x00, 0xb9,
	0x3b, 0x55, 0xa9, 0x21, 0xd6, 0xf9, 0x0c, 0x2a, 0x03, 0x74, 0x45, 0xfc, 0x40, 0x6a, 0x56, 0xbb,
	0x62, 0x9d, 0xcf, 0x6e, 0xd9, 0x50, 0x8a, 0xbc, 0xff, 0x40, 0x67, 0x60, 0xe5, 0x61, 0xab, 0x23,
	0xd7, 0x1a, 0xd5, 0x4e, 0x27, 0xf2, 0xa9, 0x0a, 0xac, 0x85, 0xd3, 0x77, 0x7b, 0x55, 0x5c, 0x6d,
	0x76, 0x45, 0xb1, 0xce, 0x73, 0xe8, 0x1c, 0xac, 0x86, 0x90, 0x9d, 0x1e, 0xee, 0x74, 0xab, 0x3b,
	0x0d, 0x91, 0x4f, 0xa1, 0xf3, 0x70, 0x26, 0x02, 0x10, 0x3b, 0x5d, 0x59, 0xbc, 0x73, 0xa7, 0x85,
	0xc9, 0xba, 0x7e, 0x83, 0x83, 0x72, 0xfc, 0x62, 0x1d, 0x5d, 0x80, 0x73, 0xb5, 0x56, 0xb3, 0x5b,
	0x95, 0x9a, 0x22, 0x96, 0x3b, 0xdd, 0x6a, 0x37, 0xba, 0xd0, 0x09, 0x40, 0x7f, 0xad, 0x1c, 0xda,
	0x80, 0xf5, 0x24, 0x30, 0xb2, 0xc0, 0xd4, 0x24, 0xe2, 0x8f, 0xaa, 0x52, 0x97, 0x10, 0xa7, 0xb7,
	0x7e, 0x05, 0xf8, 0xe4, 0x23, 0x6b, 0xc4, 0xc3, 0x62, 0xf7, 0x71, 0x3b, 0xfa, 0x7d, 0xa2, 0xfb,
	0x56, 0x5d, 0xee, 0xd4, 0x76, 0xc5, 0x7a, 0xaf, 0x41, 0x97, 0x5d, 0x84, 0x2c, 0x16, 0xab, 0xf5,
	0xc7, 0x7c, 0x0a, 0x2d, 0x43, 0x49, 0x6a, 0x4a, 0x5d, 0xa9, 0xda, 0x90, 0x3e, 0xa1, 0xea, 0x5e,
	0x81, 0xa5, 0x5e, 0xd3, 0x43, 0xa6, 0xca, 0xc8, 0xa0, 0x35, 0xe0, 0x03, 0x21, 0x3a, 0x32, 0xa3,
	0xcc, 0x6e, 0x55, 0x01, 0xc2, 0xb7, 0x79, 0x44, 0x93, 0x52, 0x5b, 0x6e, 0xe3, 0x56, 0xb7, 0x55,
	0x6b, 0x35, 0x22, 0x9f, 0xcf, 0x43, 0xba, 0x5b, 0x6b, 0xf3, 0x1c, 0xf9, 0xd1, 0xab, 0xb7, 0xf9,
	0x14, 0x71, 0xab, 0x4e, 0xad, 0xdb, 0xe6, 0xd3, 0x5b, 0x83, 0xe0, 0xad, 0x60, 0x97, 0x5d, 0x80,
	0xad, 0x75, 0x44, 0xfc, 0x48, 0xaa, 0x89, 0xf2, 0xf1, 0x35, 0x88, 0x1f, 0x77, 0x45, 0xdc, 0xac,
	0x36, 0xe4, 0x66, 0xf5, 0x01, 0x71, 0xc9, 0x32, 0x80, 0xef, 0x7f, 0x52, 0x9b, 0x79, 0x4d, 0xb3,
	0x55, 0x17, 0xe5, 0x36, 0xb5, 0x12, 0xa1, 0x68, 0xb4, 0xaa, 0x75, 0x79, 0xa7, 0xda, 0xa8, 0x36,
	0x6b, 0x22, 0xe6, 0x33, 0x5b, 0x2a, 0x9c, 0x9f, 0xfa, 0x9c, 0x91, 0xb8, 0x73, 0x17, 0x57, 0xef,
	0xdc, 0x91, 0x6a, 0x72, 0xbb, 0xd5, 0x90, 0x6a, 0x8f, 0x27, 0x88, 0xe0, 0x23, 0x34, 0x5a, 0xb5,
	0x6a, 0x83, 0xe7, 0xd0, 0x2a, 0x2c, 0xfb, 0x53, 0x9e, 0x28, 0x7c, 0x6a, 0xeb, 0x57, 0x23, 0x0f,
	0x0d, 0x29, 0xe7, 0x75, 0x38, 0x1b, 0x9a, 0x30, 0xc1, 0xf4, 0x3c, 0x9c, 0x49, 0xc0, 0xea, 0xad,
	0xda, 0x7d, 0x11, 0x33, 0xd7, 0x4c, 0x80, 0x6a, 0x58, 0x6a, 0xf1, 0x29, 0xf4, 0x35, 0x38, 0x9f,
	0x04, 0xf8, 0xc3, 0x3a, 0x9f, 0xde, 0x32, 0xa0, 0x18, 0xdc, 0xe9, 0xa0, 0xb3, 0x80, 0x98, 0x52,
	0x12, 0xc1, 0x17, 0x9f, 0x0f, 0xe3, 0x30, 0x3e, 0x1f, 0x86, 0xe4, 0x79, 0x38, 0x13, 0x99, 0x8f,
	0x78, 0x68, 0x7a, 0xeb, 0x5f, 0x38, 0x58, 0x4e, 0xdc, 0x67, 0x92, 0x25, 0x53, 0xf4, 0x6a, 0xbd,
	0x7e, 0x6c, 0xc9, 0x17, 0xe0, 0x5c, 0x02, 0x46, 0x72, 0x86, 0x67, 0xd4, 0x0d, 0x58, 0x4f, 0x00,
	0x03, 0xb3, 0x53, 0x23, 0x1f, 0x87, 0x4b, 0xcd, 0x10, 0x9e, 0x26, 0x56, 0x9c, 0x46, 0x5f, 0x6f,
	0x76, 0xf8, 0xcc, 0x04, 0x84, 0x80, 0x01, 0x41, 0xc8, 0x6e, 0xed, 0xd3, 0x87, 0x48, 0xd1, 0x53,
	0x10, 0xf4, 0x06, 0x54, 0x6a, 0xad, 0x66, 0x5d, 0xea, 0x4a, 0xad, 0x26, 0x8d, 0xc1, 0x5e, 0xe7,
	0x98, 0x09, 0xe3, 0xd0, 0x2e, 0xee, 0x91, 0xd5, 0x30, 0xcb, 0xc7, 0x41, 0x77, 0xaa, 0x8d, 0x8e,
	0xc8, 0xa7, 0xb6, 0x3e, 0xe7, 0xd8, 0x9f, 0x85, 0xc5, 0xa3, 0xd7, 0x57, 0x5c, 0x48, 0x16, 0xcb,
	0x62, 0x09, 0x18, 0x8b, 0x44, 0x0e, 0x09, 0xb0, 0x91, 0x80, 0x3c, 0x10, 0x1f, 0xb4, 0xf0, 0x63,
	0xb9, 0x8d, 0xc5, 0x4e, 0xa7, 0x87, 0x49, 0x42, 0xbb, 0x08, 0x6f, 0x24, 0x70, 0xea, 0x52, 0xe7,
	0x7e, 0x88, 0x11, 0xea, 0x2e, 0xc4, 0x68, 0x4b, 0xf5, 0x10, 0x21, 0x83, 0xde, 0x04, 0x21, 0x81,
	0xd0, 0x14, 0xbb, 0x1f, 0xb5, 0xf0, 0x7d, 0xb9, 0xd7, 0xac, 0x3e, 0xaa, 0x4a, 0x2c, 0x5d, 0x64,
	0xb7, 0x7e, 0xc8, 0xc1, 0xb9, 0x29, 0x47, 0x52, 0xe8, 0x2a, 0x5c, 0xaa, 0x8b, 0xed, 0x46, 0xeb,
	0xf1, 0x03, 0xb1, 0xd9, 0x8d, 0x70, 0x4a, 0x38, 0x89, 0x00, 0x1b, 0x13, 0xd1, 0xc2, 0xcf, 0x70,
	0xe8, 0x0a, 0x5c, 0x9c, 0x88, 0xd3, 0xc6, 0xad, 0xbb, 0x44, 0x68, 0xe6, 0xb9, 0xd7, 0xe0, 0xca,
	0x44, 0x2c, 0x2c, 0xb6, 0x1b, 0x52, 0xad, 0x2a, 0x93, 0xad, 0x85, 0xae, 0x7f, 0xeb, 0xd7, 0x39,
	0x38, 0x3b, 0xb9, 0x2f, 0x25, 0xaa, 0x89, 0x30, 0xe9, 0x74, 0x71, 0xb5, 0x2b, 0xde, 0x7d, 0x1c,
	0x91, 0xf7, 0x22, 0xbc, 0x31, 0x09, 0x01, 0x8b, 0x35, 0x2c, 0x56, 0xbb, 0x44, 0xda, 0x37, 0x41,
	0x98, 0x88, 0xd1, 0x6a, 0x34, 0xa4, 0xe6, 0x5d, 0xb9, 0xd7, 0xae, 0x13, 0xbc, 0xd4, 0xce, 0x77,
	0x3e, 0xfb, 0x62, 0x63, 0xe1, 0xf3, 0x2f, 0x36, 0x16, 0x7e, 0xf2, 0xc5, 0x06, 0xf7, 0x6b, 0xe3,
	0x0d, 0xee, 0xcf, 0xc7, 0x1b, 0xdc, 0x3f, 0x8e, 0x37, 0xb8, 0xcf, 0xc6, 0x1b, 0xdc, 0xbf, 0x8d,
	0x37, 0xb8, 0xff, 0x1c, 0x6f, 0x2c, 0xfc, 0x64, 0xbc, 0xc1, 0x7d, 0xff, 0xcb, 0x8d, 0x85, 0xcf,
	0xbe, 0xdc, 0x58, 0xf8, 0xfc, 0xcb, 0x8d, 0x85, 0x4f, 0x20, 0xac, 0x28, 0xf6, 0x72, 0xf4, 0x95,
	0xf4, 0x37, 0xfe, 0x27, 0x00, 0x00, 0xff, 0xff, 0xd1, 0x2f, 0x51, 0x4e, 0x35, 0x40, 0x00, 0x00,
}

func (x DNSPolicy) String() string {
	s, ok := DNSPolicy_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x PodPhase) String() string {
	s, ok := PodPhase_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x PodQOSClass) String() string {
	s, ok := PodQOSClass_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ContainerState) String() string {
	s, ok := ContainerState_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x PodConditionType) String() string {
	s, ok := PodConditionType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x IPProtocol) String() string {
	s, ok := IPProtocol_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ServiceType) String() string {
	s, ok := ServiceType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ExternalTrafficPolicyType) String() string {
	s, ok := ExternalTrafficPolicyType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ContainerType) String() string {
	s, ok := ContainerType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x NodePhase) String() string {
	s, ok := NodePhase_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x NodeAddressType) String() string {
	s, ok := NodeAddressType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ConditionStatus) String() string {
	s, ok := ConditionStatus_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x NodeConditionType) String() string {
	s, ok := NodeConditionType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x DeploymentConditionType) String() string {
	s, ok := DeploymentConditionType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x DeploymentStrategyType) String() string {
	s, ok := DeploymentStrategyType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *MetadataObject) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataObject)
	if !ok {
		that2, ok := that.(MetadataObject)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Object == nil {
		if this.Object != nil {
			return false
		}
	} else if this.Object == nil {
		return false
	} else if !this.Object.Equal(that1.Object) {
		return false
	}
	return true
}
func (this *MetadataObject_Pod) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataObject_Pod)
	if !ok {
		that2, ok := that.(MetadataObject_Pod)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Pod.Equal(that1.Pod) {
		return false
	}
	return true
}
func (this *MetadataObject_Endpoints) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataObject_Endpoints)
	if !ok {
		that2, ok := that.(MetadataObject_Endpoints)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Endpoints.Equal(that1.Endpoints) {
		return false
	}
	return true
}
func (this *MetadataObject_Service) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataObject_Service)
	if !ok {
		that2, ok := that.(MetadataObject_Service)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Service.Equal(that1.Service) {
		return false
	}
	return true
}
func (this *MetadataObject_Namespace) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataObject_Namespace)
	if !ok {
		that2, ok := that.(MetadataObject_Namespace)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Namespace.Equal(that1.Namespace) {
		return false
	}
	return true
}
func (this *MetadataObject_Node) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataObject_Node)
	if !ok {
		that2, ok := that.(MetadataObject_Node)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Node.Equal(that1.Node) {
		return false
	}
	return true
}
func (this *MetadataObject_ReplicaSet) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataObject_ReplicaSet)
	if !ok {
		that2, ok := that.(MetadataObject_ReplicaSet)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ReplicaSet.Equal(that1.ReplicaSet) {
		return false
	}
	return true
}
func (this *ObjectMetadata) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ObjectMetadata)
	if !ok {
		that2, ok := that.(ObjectMetadata)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if this.ResourceVersion != that1.ResourceVersion {
		return false
	}
	if this.CreationTimestampNS != that1.CreationTimestampNS {
		return false
	}
	if this.DeletionTimestampNS != that1.DeletionTimestampNS {
		return false
	}
	if len(this.Labels) != len(that1.Labels) {
		return false
	}
	for i := range this.Labels {
		if this.Labels[i] != that1.Labels[i] {
			return false
		}
	}
	if len(this.OwnerReferences) != len(that1.OwnerReferences) {
		return false
	}
	for i := range this.OwnerReferences {
		if !this.OwnerReferences[i].Equal(that1.OwnerReferences[i]) {
			return false
		}
	}
	if len(this.Annotations) != len(that1.Annotations) {
		return false
	}
	for i := range this.Annotations {
		if this.Annotations[i] != that1.Annotations[i] {
			return false
		}
	}
	return true
}
func (this *OwnerReference) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OwnerReference)
	if !ok {
		that2, ok := that.(OwnerReference)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Kind != that1.Kind {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	return true
}
func (this *Namespace) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Namespace)
	if !ok {
		that2, ok := that.(Namespace)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	return true
}
func (this *Pod) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Pod)
	if !ok {
		that2, ok := that.(Pod)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	if !this.Spec.Equal(that1.Spec) {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	return true
}
func (this *PodSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PodSpec)
	if !ok {
		that2, ok := that.(PodSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DNSPolicy != that1.DNSPolicy {
		return false
	}
	if len(this.NodeSelector) != len(that1.NodeSelector) {
		return false
	}
	for i := range this.NodeSelector {
		if this.NodeSelector[i] != that1.NodeSelector[i] {
			return false
		}
	}
	if this.NodeName != that1.NodeName {
		return false
	}
	if this.Hostname != that1.Hostname {
		return false
	}
	if this.Subdomain != that1.Subdomain {
		return false
	}
	if this.PriorityClassName != that1.PriorityClassName {
		return false
	}
	if this.Priority != that1.Priority {
		return false
	}
	return true
}
func (this *ContainerStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ContainerStatus)
	if !ok {
		that2, ok := that.(ContainerStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ContainerID != that1.ContainerID {
		return false
	}
	if this.ContainerState != that1.ContainerState {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.Reason != that1.Reason {
		return false
	}
	if this.RestartCount != that1.RestartCount {
		return false
	}
	return true
}
func (this *K8SEvent) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*K8SEvent)
	if !ok {
		that2, ok := that.(K8SEvent)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if !this.FirstTime.Equal(that1.FirstTime) {
		return false
	}
	if !this.LastTime.Equal(that1.LastTime) {
		return false
	}
	return true
}
func (this *PodStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PodStatus)
	if !ok {
		that2, ok := that.(PodStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Phase != that1.Phase {
		return false
	}
	if len(this.Conditions) != len(that1.Conditions) {
		return false
	}
	for i := range this.Conditions {
		if !this.Conditions[i].Equal(that1.Conditions[i]) {
			return false
		}
	}
	if this.Message != that1.Message {
		return false
	}
	if this.Reason != that1.Reason {
		return false
	}
	if this.HostIP != that1.HostIP {
		return false
	}
	if this.PodIP != that1.PodIP {
		return false
	}
	if this.QOSClass != that1.QOSClass {
		return false
	}
	if len(this.ContainerStatuses) != len(that1.ContainerStatuses) {
		return false
	}
	for i := range this.ContainerStatuses {
		if !this.ContainerStatuses[i].Equal(that1.ContainerStatuses[i]) {
			return false
		}
	}
	if !this.CreatedAt.Equal(that1.CreatedAt) {
		return false
	}
	if len(this.Events) != len(that1.Events) {
		return false
	}
	for i := range this.Events {
		if !this.Events[i].Equal(that1.Events[i]) {
			return false
		}
	}
	if this.RestartCount != that1.RestartCount {
		return false
	}
	return true
}
func (this *PodCondition) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PodCondition)
	if !ok {
		that2, ok := that.(PodCondition)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	return true
}
func (this *Endpoints) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Endpoints)
	if !ok {
		that2, ok := that.(Endpoints)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	if len(this.Subsets) != len(that1.Subsets) {
		return false
	}
	for i := range this.Subsets {
		if !this.Subsets[i].Equal(that1.Subsets[i]) {
			return false
		}
	}
	return true
}
func (this *EndpointSubset) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EndpointSubset)
	if !ok {
		that2, ok := that.(EndpointSubset)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Addresses) != len(that1.Addresses) {
		return false
	}
	for i := range this.Addresses {
		if !this.Addresses[i].Equal(that1.Addresses[i]) {
			return false
		}
	}
	if len(this.NotReadyAddresses) != len(that1.NotReadyAddresses) {
		return false
	}
	for i := range this.NotReadyAddresses {
		if !this.NotReadyAddresses[i].Equal(that1.NotReadyAddresses[i]) {
			return false
		}
	}
	if len(this.Ports) != len(that1.Ports) {
		return false
	}
	for i := range this.Ports {
		if !this.Ports[i].Equal(that1.Ports[i]) {
			return false
		}
	}
	return true
}
func (this *EndpointAddress) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EndpointAddress)
	if !ok {
		that2, ok := that.(EndpointAddress)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.IP != that1.IP {
		return false
	}
	if this.Hostname != that1.Hostname {
		return false
	}
	if this.NodeName != that1.NodeName {
		return false
	}
	if !this.TargetRef.Equal(that1.TargetRef) {
		return false
	}
	return true
}
func (this *EndpointPort) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*EndpointPort)
	if !ok {
		that2, ok := that.(EndpointPort)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Port != that1.Port {
		return false
	}
	if this.Protocol != that1.Protocol {
		return false
	}
	return true
}
func (this *ObjectReference) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ObjectReference)
	if !ok {
		that2, ok := that.(ObjectReference)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Kind != that1.Kind {
		return false
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if this.ResourceVersion != that1.ResourceVersion {
		return false
	}
	return true
}
func (this *Service) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Service)
	if !ok {
		that2, ok := that.(Service)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	if !this.Spec.Equal(that1.Spec) {
		return false
	}
	return true
}
func (this *ServiceSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ServiceSpec)
	if !ok {
		that2, ok := that.(ServiceSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Ports) != len(that1.Ports) {
		return false
	}
	for i := range this.Ports {
		if !this.Ports[i].Equal(that1.Ports[i]) {
			return false
		}
	}
	if this.ClusterIP != that1.ClusterIP {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if len(this.ExternalIPs) != len(that1.ExternalIPs) {
		return false
	}
	for i := range this.ExternalIPs {
		if this.ExternalIPs[i] != that1.ExternalIPs[i] {
			return false
		}
	}
	if this.LoadBalancerIP != that1.LoadBalancerIP {
		return false
	}
	if this.ExternalName != that1.ExternalName {
		return false
	}
	if this.ExternalTrafficPolicy != that1.ExternalTrafficPolicy {
		return false
	}
	return true
}
func (this *ServicePort) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ServicePort)
	if !ok {
		that2, ok := that.(ServicePort)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Protocol != that1.Protocol {
		return false
	}
	if this.Port != that1.Port {
		return false
	}
	if this.NodePort != that1.NodePort {
		return false
	}
	return true
}
func (this *ContainerInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ContainerInfo)
	if !ok {
		that2, ok := that.(ContainerInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	if this.PodUID != that1.PodUID {
		return false
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if len(this.Processes) != len(that1.Processes) {
		return false
	}
	for i := range this.Processes {
		if !this.Processes[i].Equal(that1.Processes[i]) {
			return false
		}
	}
	return true
}
func (this *ProcessInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ProcessInfo)
	if !ok {
		that2, ok := that.(ProcessInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.UPID.Equal(that1.UPID) {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	if this.ProcessArgs != that1.ProcessArgs {
		return false
	}
	if this.CID != that1.CID {
		return false
	}
	return true
}
func (this *PodUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PodUpdate)
	if !ok {
		that2, ok := that.(PodUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	if len(this.ContainerIDs) != len(that1.ContainerIDs) {
		return false
	}
	for i := range this.ContainerIDs {
		if this.ContainerIDs[i] != that1.ContainerIDs[i] {
			return false
		}
	}
	if len(this.ContainerNames) != len(that1.ContainerNames) {
		return false
	}
	for i := range this.ContainerNames {
		if this.ContainerNames[i] != that1.ContainerNames[i] {
			return false
		}
	}
	if this.QOSClass != that1.QOSClass {
		return false
	}
	if this.Phase != that1.Phase {
		return false
	}
	if len(this.Conditions) != len(that1.Conditions) {
		return false
	}
	for i := range this.Conditions {
		if !this.Conditions[i].Equal(that1.Conditions[i]) {
			return false
		}
	}
	if this.NodeName != that1.NodeName {
		return false
	}
	if this.Hostname != that1.Hostname {
		return false
	}
	if this.PodIP != that1.PodIP {
		return false
	}
	if this.HostIP != that1.HostIP {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.Reason != that1.Reason {
		return false
	}
	if this.Labels != that1.Labels {
		return false
	}
	if len(this.OwnerReferences) != len(that1.OwnerReferences) {
		return false
	}
	for i := range this.OwnerReferences {
		if !this.OwnerReferences[i].Equal(that1.OwnerReferences[i]) {
			return false
		}
	}
	return true
}
func (this *ContainerUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ContainerUpdate)
	if !ok {
		that2, ok := that.(ContainerUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.CID != that1.CID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if this.PodID != that1.PodID {
		return false
	}
	if this.PodName != that1.PodName {
		return false
	}
	if this.ContainerState != that1.ContainerState {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.Reason != that1.Reason {
		return false
	}
	if this.ContainerType != that1.ContainerType {
		return false
	}
	return true
}
func (this *ServiceUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ServiceUpdate)
	if !ok {
		that2, ok := that.(ServiceUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	if len(this.PodIDs) != len(that1.PodIDs) {
		return false
	}
	for i := range this.PodIDs {
		if this.PodIDs[i] != that1.PodIDs[i] {
			return false
		}
	}
	if len(this.PodNames) != len(that1.PodNames) {
		return false
	}
	for i := range this.PodNames {
		if this.PodNames[i] != that1.PodNames[i] {
			return false
		}
	}
	if len(this.ExternalIPs) != len(that1.ExternalIPs) {
		return false
	}
	for i := range this.ExternalIPs {
		if this.ExternalIPs[i] != that1.ExternalIPs[i] {
			return false
		}
	}
	if this.ClusterIP != that1.ClusterIP {
		return false
	}
	return true
}
func (this *NamespaceUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NamespaceUpdate)
	if !ok {
		that2, ok := that.(NamespaceUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	return true
}
func (this *ProcessCreated) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ProcessCreated)
	if !ok {
		that2, ok := that.(ProcessCreated)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.UPID.Equal(that1.UPID) {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.Cmdline != that1.Cmdline {
		return false
	}
	if this.CID != that1.CID {
		return false
	}
	return true
}
func (this *ProcessTerminated) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ProcessTerminated)
	if !ok {
		that2, ok := that.(ProcessTerminated)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.UPID.Equal(that1.UPID) {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	return true
}
func (this *Node) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Node)
	if !ok {
		that2, ok := that.(Node)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	if !this.Spec.Equal(that1.Spec) {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	return true
}
func (this *NodeSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NodeSpec)
	if !ok {
		that2, ok := that.(NodeSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.PodCIDRs) != len(that1.PodCIDRs) {
		return false
	}
	for i := range this.PodCIDRs {
		if this.PodCIDRs[i] != that1.PodCIDRs[i] {
			return false
		}
	}
	if this.PodCIDR != that1.PodCIDR {
		return false
	}
	return true
}
func (this *NodeAddress) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NodeAddress)
	if !ok {
		that2, ok := that.(NodeAddress)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Address != that1.Address {
		return false
	}
	return true
}
func (this *NodeCondition) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NodeCondition)
	if !ok {
		that2, ok := that.(NodeCondition)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	return true
}
func (this *NodeStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NodeStatus)
	if !ok {
		that2, ok := that.(NodeStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Phase != that1.Phase {
		return false
	}
	if len(this.Addresses) != len(that1.Addresses) {
		return false
	}
	for i := range this.Addresses {
		if !this.Addresses[i].Equal(that1.Addresses[i]) {
			return false
		}
	}
	if len(this.Conditions) != len(that1.Conditions) {
		return false
	}
	for i := range this.Conditions {
		if !this.Conditions[i].Equal(that1.Conditions[i]) {
			return false
		}
	}
	return true
}
func (this *NodeUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NodeUpdate)
	if !ok {
		that2, ok := that.(NodeUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	if this.Phase != that1.Phase {
		return false
	}
	if this.PodCIDR != that1.PodCIDR {
		return false
	}
	if len(this.PodCIDRs) != len(that1.PodCIDRs) {
		return false
	}
	for i := range this.PodCIDRs {
		if this.PodCIDRs[i] != that1.PodCIDRs[i] {
			return false
		}
	}
	if len(this.Conditions) != len(that1.Conditions) {
		return false
	}
	for i := range this.Conditions {
		if !this.Conditions[i].Equal(that1.Conditions[i]) {
			return false
		}
	}
	return true
}
func (this *ReplicaSet) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicaSet)
	if !ok {
		that2, ok := that.(ReplicaSet)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	if !this.Spec.Equal(that1.Spec) {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	return true
}
func (this *ReplicaSetCondition) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicaSetCondition)
	if !ok {
		that2, ok := that.(ReplicaSetCondition)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	return true
}
func (this *LabelSelectorRequirement) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LabelSelectorRequirement)
	if !ok {
		that2, ok := that.(LabelSelectorRequirement)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if this.Operator != that1.Operator {
		return false
	}
	if len(this.Values) != len(that1.Values) {
		return false
	}
	for i := range this.Values {
		if this.Values[i] != that1.Values[i] {
			return false
		}
	}
	return true
}
func (this *LabelSelector) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LabelSelector)
	if !ok {
		that2, ok := that.(LabelSelector)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.MatchLabels) != len(that1.MatchLabels) {
		return false
	}
	for i := range this.MatchLabels {
		if this.MatchLabels[i] != that1.MatchLabels[i] {
			return false
		}
	}
	if len(this.MatchExpressions) != len(that1.MatchExpressions) {
		return false
	}
	for i := range this.MatchExpressions {
		if !this.MatchExpressions[i].Equal(that1.MatchExpressions[i]) {
			return false
		}
	}
	return true
}
func (this *PodTemplateSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PodTemplateSpec)
	if !ok {
		that2, ok := that.(PodTemplateSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	if !this.Spec.Equal(that1.Spec) {
		return false
	}
	return true
}
func (this *ReplicaSetSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicaSetSpec)
	if !ok {
		that2, ok := that.(ReplicaSetSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Replicas != that1.Replicas {
		return false
	}
	if this.MinReadySeconds != that1.MinReadySeconds {
		return false
	}
	if !this.Selector.Equal(that1.Selector) {
		return false
	}
	if !this.Template.Equal(that1.Template) {
		return false
	}
	return true
}
func (this *ReplicaSetStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicaSetStatus)
	if !ok {
		that2, ok := that.(ReplicaSetStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Replicas != that1.Replicas {
		return false
	}
	if this.FullyLabeledReplicas != that1.FullyLabeledReplicas {
		return false
	}
	if this.ReadyReplicas != that1.ReadyReplicas {
		return false
	}
	if this.AvailableReplicas != that1.AvailableReplicas {
		return false
	}
	if this.ObservedGeneration != that1.ObservedGeneration {
		return false
	}
	if len(this.Conditions) != len(that1.Conditions) {
		return false
	}
	for i := range this.Conditions {
		if !this.Conditions[i].Equal(that1.Conditions[i]) {
			return false
		}
	}
	return true
}
func (this *ReplicaSetUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicaSetUpdate)
	if !ok {
		that2, ok := that.(ReplicaSetUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if this.Replicas != that1.Replicas {
		return false
	}
	if this.FullyLabeledReplicas != that1.FullyLabeledReplicas {
		return false
	}
	if this.ReadyReplicas != that1.ReadyReplicas {
		return false
	}
	if this.AvailableReplicas != that1.AvailableReplicas {
		return false
	}
	if this.ObservedGeneration != that1.ObservedGeneration {
		return false
	}
	if this.RequestedReplicas != that1.RequestedReplicas {
		return false
	}
	if len(this.Conditions) != len(that1.Conditions) {
		return false
	}
	for i := range this.Conditions {
		if !this.Conditions[i].Equal(that1.Conditions[i]) {
			return false
		}
	}
	if len(this.OwnerReferences) != len(that1.OwnerReferences) {
		return false
	}
	for i := range this.OwnerReferences {
		if !this.OwnerReferences[i].Equal(that1.OwnerReferences[i]) {
			return false
		}
	}
	return true
}
func (this *Deployment) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Deployment)
	if !ok {
		that2, ok := that.(Deployment)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Metadata.Equal(that1.Metadata) {
		return false
	}
	if !this.Spec.Equal(that1.Spec) {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	return true
}
func (this *DeploymentCondition) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentCondition)
	if !ok {
		that2, ok := that.(DeploymentCondition)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if this.LastUpdateTimeNS != that1.LastUpdateTimeNS {
		return false
	}
	if this.LastTransitionTimeNS != that1.LastTransitionTimeNS {
		return false
	}
	if this.Reason != that1.Reason {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	return true
}
func (this *DeploymentStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentStatus)
	if !ok {
		that2, ok := that.(DeploymentStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ObservedGeneration != that1.ObservedGeneration {
		return false
	}
	if this.Replicas != that1.Replicas {
		return false
	}
	if this.UpdatedReplicas != that1.UpdatedReplicas {
		return false
	}
	if this.ReadyReplicas != that1.ReadyReplicas {
		return false
	}
	if this.AvailableReplicas != that1.AvailableReplicas {
		return false
	}
	if this.UnavailableReplicas != that1.UnavailableReplicas {
		return false
	}
	if len(this.Conditions) != len(that1.Conditions) {
		return false
	}
	for i := range this.Conditions {
		if !this.Conditions[i].Equal(that1.Conditions[i]) {
			return false
		}
	}
	if this.CollisionCount != that1.CollisionCount {
		return false
	}
	return true
}
func (this *DeploymentSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentSpec)
	if !ok {
		that2, ok := that.(DeploymentSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Replicas != that1.Replicas {
		return false
	}
	if !this.Selector.Equal(that1.Selector) {
		return false
	}
	if !this.Template.Equal(that1.Template) {
		return false
	}
	if !this.Strategy.Equal(that1.Strategy) {
		return false
	}
	if this.MinReadySeconds != that1.MinReadySeconds {
		return false
	}
	if this.RevisionHistoryLimit != that1.RevisionHistoryLimit {
		return false
	}
	if this.Paused != that1.Paused {
		return false
	}
	if this.ProgressDeadlineSeconds != that1.ProgressDeadlineSeconds {
		return false
	}
	return true
}
func (this *DeploymentStrategy) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentStrategy)
	if !ok {
		that2, ok := that.(DeploymentStrategy)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if !this.RollingUpdate.Equal(that1.RollingUpdate) {
		return false
	}
	return true
}
func (this *RollingUpdateDeployment) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RollingUpdateDeployment)
	if !ok {
		that2, ok := that.(RollingUpdateDeployment)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MaxUnavailable != that1.MaxUnavailable {
		return false
	}
	if this.MaxSurge != that1.MaxSurge {
		return false
	}
	return true
}
func (this *DeploymentUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentUpdate)
	if !ok {
		that2, ok := that.(DeploymentUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UID != that1.UID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.StopTimestampNS != that1.StopTimestampNS {
		return false
	}
	if this.Namespace != that1.Namespace {
		return false
	}
	if this.ObservedGeneration != that1.ObservedGeneration {
		return false
	}
	if this.Replicas != that1.Replicas {
		return false
	}
	if this.UpdatedReplicas != that1.UpdatedReplicas {
		return false
	}
	if this.ReadyReplicas != that1.ReadyReplicas {
		return false
	}
	if this.AvailableReplicas != that1.AvailableReplicas {
		return false
	}
	if this.UnavailableReplicas != that1.UnavailableReplicas {
		return false
	}
	if this.RequestedReplicas != that1.RequestedReplicas {
		return false
	}
	if len(this.Conditions) != len(that1.Conditions) {
		return false
	}
	for i := range this.Conditions {
		if !this.Conditions[i].Equal(that1.Conditions[i]) {
			return false
		}
	}
	return true
}
func (this *ResourceUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceUpdate)
	if !ok {
		that2, ok := that.(ResourceUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Update == nil {
		if this.Update != nil {
			return false
		}
	} else if this.Update == nil {
		return false
	} else if !this.Update.Equal(that1.Update) {
		return false
	}
	if this.UpdateVersion != that1.UpdateVersion {
		return false
	}
	if this.PrevUpdateVersion != that1.PrevUpdateVersion {
		return false
	}
	return true
}
func (this *ResourceUpdate_PodUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceUpdate_PodUpdate)
	if !ok {
		that2, ok := that.(ResourceUpdate_PodUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.PodUpdate.Equal(that1.PodUpdate) {
		return false
	}
	return true
}
func (this *ResourceUpdate_ContainerUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceUpdate_ContainerUpdate)
	if !ok {
		that2, ok := that.(ResourceUpdate_ContainerUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ContainerUpdate.Equal(that1.ContainerUpdate) {
		return false
	}
	return true
}
func (this *ResourceUpdate_ServiceUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceUpdate_ServiceUpdate)
	if !ok {
		that2, ok := that.(ResourceUpdate_ServiceUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ServiceUpdate.Equal(that1.ServiceUpdate) {
		return false
	}
	return true
}
func (this *ResourceUpdate_NamespaceUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceUpdate_NamespaceUpdate)
	if !ok {
		that2, ok := that.(ResourceUpdate_NamespaceUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.NamespaceUpdate.Equal(that1.NamespaceUpdate) {
		return false
	}
	return true
}
func (this *ResourceUpdate_NodeUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceUpdate_NodeUpdate)
	if !ok {
		that2, ok := that.(ResourceUpdate_NodeUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.NodeUpdate.Equal(that1.NodeUpdate) {
		return false
	}
	return true
}
func (this *ResourceUpdate_ReplicaSetUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceUpdate_ReplicaSetUpdate)
	if !ok {
		that2, ok := that.(ResourceUpdate_ReplicaSetUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ReplicaSetUpdate.Equal(that1.ReplicaSetUpdate) {
		return false
	}
	return true
}
func (this *ResourceUpdate_DeploymentUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResourceUpdate_DeploymentUpdate)
	if !ok {
		that2, ok := that.(ResourceUpdate_DeploymentUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.DeploymentUpdate.Equal(that1.DeploymentUpdate) {
		return false
	}
	return true
}
func (this *MissingK8SMetadataRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MissingK8SMetadataRequest)
	if !ok {
		that2, ok := that.(MissingK8SMetadataRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Selector != that1.Selector {
		return false
	}
	if this.FromUpdateVersion != that1.FromUpdateVersion {
		return false
	}
	if this.ToUpdateVersion != that1.ToUpdateVersion {
		return false
	}
	if this.CustomTopic != that1.CustomTopic {
		return false
	}
	return true
}
func (this *MissingK8SMetadataResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MissingK8SMetadataResponse)
	if !ok {
		that2, ok := that.(MissingK8SMetadataResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Updates) != len(that1.Updates) {
		return false
	}
	for i := range this.Updates {
		if !this.Updates[i].Equal(that1.Updates[i]) {
			return false
		}
	}
	if this.FirstUpdateAvailable != that1.FirstUpdateAvailable {
		return false
	}
	if this.LastUpdateAvailable != that1.LastUpdateAvailable {
		return false
	}
	return true
}
func (this *MetadataObject) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&metadatapb.MetadataObject{")
	if this.Object != nil {
		s = append(s, "Object: "+fmt.Sprintf("%#v", this.Object)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MetadataObject_Pod) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.MetadataObject_Pod{` +
		`Pod:` + fmt.Sprintf("%#v", this.Pod) + `}`}, ", ")
	return s
}
func (this *MetadataObject_Endpoints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.MetadataObject_Endpoints{` +
		`Endpoints:` + fmt.Sprintf("%#v", this.Endpoints) + `}`}, ", ")
	return s
}
func (this *MetadataObject_Service) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.MetadataObject_Service{` +
		`Service:` + fmt.Sprintf("%#v", this.Service) + `}`}, ", ")
	return s
}
func (this *MetadataObject_Namespace) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.MetadataObject_Namespace{` +
		`Namespace:` + fmt.Sprintf("%#v", this.Namespace) + `}`}, ", ")
	return s
}
func (this *MetadataObject_Node) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.MetadataObject_Node{` +
		`Node:` + fmt.Sprintf("%#v", this.Node) + `}`}, ", ")
	return s
}
func (this *MetadataObject_ReplicaSet) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.MetadataObject_ReplicaSet{` +
		`ReplicaSet:` + fmt.Sprintf("%#v", this.ReplicaSet) + `}`}, ", ")
	return s
}
func (this *ObjectMetadata) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&metadatapb.ObjectMetadata{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "ResourceVersion: "+fmt.Sprintf("%#v", this.ResourceVersion)+",\n")
	s = append(s, "CreationTimestampNS: "+fmt.Sprintf("%#v", this.CreationTimestampNS)+",\n")
	s = append(s, "DeletionTimestampNS: "+fmt.Sprintf("%#v", this.DeletionTimestampNS)+",\n")
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%#v: %#v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	if this.Labels != nil {
		s = append(s, "Labels: "+mapStringForLabels+",\n")
	}
	if this.OwnerReferences != nil {
		s = append(s, "OwnerReferences: "+fmt.Sprintf("%#v", this.OwnerReferences)+",\n")
	}
	keysForAnnotations := make([]string, 0, len(this.Annotations))
	for k, _ := range this.Annotations {
		keysForAnnotations = append(keysForAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
	mapStringForAnnotations := "map[string]string{"
	for _, k := range keysForAnnotations {
		mapStringForAnnotations += fmt.Sprintf("%#v: %#v,", k, this.Annotations[k])
	}
	mapStringForAnnotations += "}"
	if this.Annotations != nil {
		s = append(s, "Annotations: "+mapStringForAnnotations+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *OwnerReference) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.OwnerReference{")
	s = append(s, "Kind: "+fmt.Sprintf("%#v", this.Kind)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Namespace) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&metadatapb.Namespace{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Pod) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.Pod{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	if this.Spec != nil {
		s = append(s, "Spec: "+fmt.Sprintf("%#v", this.Spec)+",\n")
	}
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PodSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&metadatapb.PodSpec{")
	s = append(s, "DNSPolicy: "+fmt.Sprintf("%#v", this.DNSPolicy)+",\n")
	keysForNodeSelector := make([]string, 0, len(this.NodeSelector))
	for k, _ := range this.NodeSelector {
		keysForNodeSelector = append(keysForNodeSelector, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
	mapStringForNodeSelector := "map[string]string{"
	for _, k := range keysForNodeSelector {
		mapStringForNodeSelector += fmt.Sprintf("%#v: %#v,", k, this.NodeSelector[k])
	}
	mapStringForNodeSelector += "}"
	if this.NodeSelector != nil {
		s = append(s, "NodeSelector: "+mapStringForNodeSelector+",\n")
	}
	s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
	s = append(s, "Hostname: "+fmt.Sprintf("%#v", this.Hostname)+",\n")
	s = append(s, "Subdomain: "+fmt.Sprintf("%#v", this.Subdomain)+",\n")
	s = append(s, "PriorityClassName: "+fmt.Sprintf("%#v", this.PriorityClassName)+",\n")
	s = append(s, "Priority: "+fmt.Sprintf("%#v", this.Priority)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ContainerStatus) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&metadatapb.ContainerStatus{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ContainerID: "+fmt.Sprintf("%#v", this.ContainerID)+",\n")
	s = append(s, "ContainerState: "+fmt.Sprintf("%#v", this.ContainerState)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "Reason: "+fmt.Sprintf("%#v", this.Reason)+",\n")
	s = append(s, "RestartCount: "+fmt.Sprintf("%#v", this.RestartCount)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *K8SEvent) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.K8SEvent{")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	if this.FirstTime != nil {
		s = append(s, "FirstTime: "+fmt.Sprintf("%#v", this.FirstTime)+",\n")
	}
	if this.LastTime != nil {
		s = append(s, "LastTime: "+fmt.Sprintf("%#v", this.LastTime)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PodStatus) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&metadatapb.PodStatus{")
	s = append(s, "Phase: "+fmt.Sprintf("%#v", this.Phase)+",\n")
	if this.Conditions != nil {
		s = append(s, "Conditions: "+fmt.Sprintf("%#v", this.Conditions)+",\n")
	}
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "Reason: "+fmt.Sprintf("%#v", this.Reason)+",\n")
	s = append(s, "HostIP: "+fmt.Sprintf("%#v", this.HostIP)+",\n")
	s = append(s, "PodIP: "+fmt.Sprintf("%#v", this.PodIP)+",\n")
	s = append(s, "QOSClass: "+fmt.Sprintf("%#v", this.QOSClass)+",\n")
	if this.ContainerStatuses != nil {
		s = append(s, "ContainerStatuses: "+fmt.Sprintf("%#v", this.ContainerStatuses)+",\n")
	}
	if this.CreatedAt != nil {
		s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	}
	if this.Events != nil {
		s = append(s, "Events: "+fmt.Sprintf("%#v", this.Events)+",\n")
	}
	s = append(s, "RestartCount: "+fmt.Sprintf("%#v", this.RestartCount)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PodCondition) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.PodCondition{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Endpoints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.Endpoints{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	if this.Subsets != nil {
		s = append(s, "Subsets: "+fmt.Sprintf("%#v", this.Subsets)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EndpointSubset) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.EndpointSubset{")
	if this.Addresses != nil {
		s = append(s, "Addresses: "+fmt.Sprintf("%#v", this.Addresses)+",\n")
	}
	if this.NotReadyAddresses != nil {
		s = append(s, "NotReadyAddresses: "+fmt.Sprintf("%#v", this.NotReadyAddresses)+",\n")
	}
	if this.Ports != nil {
		s = append(s, "Ports: "+fmt.Sprintf("%#v", this.Ports)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EndpointAddress) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.EndpointAddress{")
	s = append(s, "IP: "+fmt.Sprintf("%#v", this.IP)+",\n")
	s = append(s, "Hostname: "+fmt.Sprintf("%#v", this.Hostname)+",\n")
	s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
	if this.TargetRef != nil {
		s = append(s, "TargetRef: "+fmt.Sprintf("%#v", this.TargetRef)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EndpointPort) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.EndpointPort{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Port: "+fmt.Sprintf("%#v", this.Port)+",\n")
	s = append(s, "Protocol: "+fmt.Sprintf("%#v", this.Protocol)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ObjectReference) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&metadatapb.ObjectReference{")
	s = append(s, "Kind: "+fmt.Sprintf("%#v", this.Kind)+",\n")
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "ResourceVersion: "+fmt.Sprintf("%#v", this.ResourceVersion)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Service) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.Service{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	if this.Spec != nil {
		s = append(s, "Spec: "+fmt.Sprintf("%#v", this.Spec)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ServiceSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&metadatapb.ServiceSpec{")
	if this.Ports != nil {
		s = append(s, "Ports: "+fmt.Sprintf("%#v", this.Ports)+",\n")
	}
	s = append(s, "ClusterIP: "+fmt.Sprintf("%#v", this.ClusterIP)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "ExternalIPs: "+fmt.Sprintf("%#v", this.ExternalIPs)+",\n")
	s = append(s, "LoadBalancerIP: "+fmt.Sprintf("%#v", this.LoadBalancerIP)+",\n")
	s = append(s, "ExternalName: "+fmt.Sprintf("%#v", this.ExternalName)+",\n")
	s = append(s, "ExternalTrafficPolicy: "+fmt.Sprintf("%#v", this.ExternalTrafficPolicy)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ServicePort) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.ServicePort{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Protocol: "+fmt.Sprintf("%#v", this.Protocol)+",\n")
	s = append(s, "Port: "+fmt.Sprintf("%#v", this.Port)+",\n")
	s = append(s, "NodePort: "+fmt.Sprintf("%#v", this.NodePort)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ContainerInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&metadatapb.ContainerInfo{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "PodUID: "+fmt.Sprintf("%#v", this.PodUID)+",\n")
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	if this.Processes != nil {
		s = append(s, "Processes: "+fmt.Sprintf("%#v", this.Processes)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ProcessInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&metadatapb.ProcessInfo{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.UPID != nil {
		s = append(s, "UPID: "+fmt.Sprintf("%#v", this.UPID)+",\n")
	}
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "ProcessArgs: "+fmt.Sprintf("%#v", this.ProcessArgs)+",\n")
	s = append(s, "CID: "+fmt.Sprintf("%#v", this.CID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PodUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 22)
	s = append(s, "&metadatapb.PodUpdate{")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "ContainerIDs: "+fmt.Sprintf("%#v", this.ContainerIDs)+",\n")
	s = append(s, "ContainerNames: "+fmt.Sprintf("%#v", this.ContainerNames)+",\n")
	s = append(s, "QOSClass: "+fmt.Sprintf("%#v", this.QOSClass)+",\n")
	s = append(s, "Phase: "+fmt.Sprintf("%#v", this.Phase)+",\n")
	if this.Conditions != nil {
		s = append(s, "Conditions: "+fmt.Sprintf("%#v", this.Conditions)+",\n")
	}
	s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
	s = append(s, "Hostname: "+fmt.Sprintf("%#v", this.Hostname)+",\n")
	s = append(s, "PodIP: "+fmt.Sprintf("%#v", this.PodIP)+",\n")
	s = append(s, "HostIP: "+fmt.Sprintf("%#v", this.HostIP)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "Reason: "+fmt.Sprintf("%#v", this.Reason)+",\n")
	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
	if this.OwnerReferences != nil {
		s = append(s, "OwnerReferences: "+fmt.Sprintf("%#v", this.OwnerReferences)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ContainerUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&metadatapb.ContainerUpdate{")
	s = append(s, "CID: "+fmt.Sprintf("%#v", this.CID)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	s = append(s, "PodID: "+fmt.Sprintf("%#v", this.PodID)+",\n")
	s = append(s, "PodName: "+fmt.Sprintf("%#v", this.PodName)+",\n")
	s = append(s, "ContainerState: "+fmt.Sprintf("%#v", this.ContainerState)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "Reason: "+fmt.Sprintf("%#v", this.Reason)+",\n")
	s = append(s, "ContainerType: "+fmt.Sprintf("%#v", this.ContainerType)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ServiceUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&metadatapb.ServiceUpdate{")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "PodIDs: "+fmt.Sprintf("%#v", this.PodIDs)+",\n")
	s = append(s, "PodNames: "+fmt.Sprintf("%#v", this.PodNames)+",\n")
	s = append(s, "ExternalIPs: "+fmt.Sprintf("%#v", this.ExternalIPs)+",\n")
	s = append(s, "ClusterIP: "+fmt.Sprintf("%#v", this.ClusterIP)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NamespaceUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.NamespaceUpdate{")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ProcessCreated) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.ProcessCreated{")
	if this.UPID != nil {
		s = append(s, "UPID: "+fmt.Sprintf("%#v", this.UPID)+",\n")
	}
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "Cmdline: "+fmt.Sprintf("%#v", this.Cmdline)+",\n")
	s = append(s, "CID: "+fmt.Sprintf("%#v", this.CID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ProcessTerminated) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.ProcessTerminated{")
	if this.UPID != nil {
		s = append(s, "UPID: "+fmt.Sprintf("%#v", this.UPID)+",\n")
	}
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Node) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.Node{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	if this.Spec != nil {
		s = append(s, "Spec: "+fmt.Sprintf("%#v", this.Spec)+",\n")
	}
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NodeSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.NodeSpec{")
	s = append(s, "PodCIDRs: "+fmt.Sprintf("%#v", this.PodCIDRs)+",\n")
	s = append(s, "PodCIDR: "+fmt.Sprintf("%#v", this.PodCIDR)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NodeAddress) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.NodeAddress{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Address: "+fmt.Sprintf("%#v", this.Address)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NodeCondition) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.NodeCondition{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NodeStatus) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.NodeStatus{")
	s = append(s, "Phase: "+fmt.Sprintf("%#v", this.Phase)+",\n")
	if this.Addresses != nil {
		s = append(s, "Addresses: "+fmt.Sprintf("%#v", this.Addresses)+",\n")
	}
	if this.Conditions != nil {
		s = append(s, "Conditions: "+fmt.Sprintf("%#v", this.Conditions)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NodeUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&metadatapb.NodeUpdate{")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "Phase: "+fmt.Sprintf("%#v", this.Phase)+",\n")
	s = append(s, "PodCIDR: "+fmt.Sprintf("%#v", this.PodCIDR)+",\n")
	s = append(s, "PodCIDRs: "+fmt.Sprintf("%#v", this.PodCIDRs)+",\n")
	if this.Conditions != nil {
		s = append(s, "Conditions: "+fmt.Sprintf("%#v", this.Conditions)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ReplicaSet) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.ReplicaSet{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	if this.Spec != nil {
		s = append(s, "Spec: "+fmt.Sprintf("%#v", this.Spec)+",\n")
	}
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ReplicaSetCondition) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.ReplicaSetCondition{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LabelSelectorRequirement) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.LabelSelectorRequirement{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "Operator: "+fmt.Sprintf("%#v", this.Operator)+",\n")
	s = append(s, "Values: "+fmt.Sprintf("%#v", this.Values)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LabelSelector) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.LabelSelector{")
	keysForMatchLabels := make([]string, 0, len(this.MatchLabels))
	for k, _ := range this.MatchLabels {
		keysForMatchLabels = append(keysForMatchLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels)
	mapStringForMatchLabels := "map[string]string{"
	for _, k := range keysForMatchLabels {
		mapStringForMatchLabels += fmt.Sprintf("%#v: %#v,", k, this.MatchLabels[k])
	}
	mapStringForMatchLabels += "}"
	if this.MatchLabels != nil {
		s = append(s, "MatchLabels: "+mapStringForMatchLabels+",\n")
	}
	if this.MatchExpressions != nil {
		s = append(s, "MatchExpressions: "+fmt.Sprintf("%#v", this.MatchExpressions)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PodTemplateSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.PodTemplateSpec{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	if this.Spec != nil {
		s = append(s, "Spec: "+fmt.Sprintf("%#v", this.Spec)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ReplicaSetSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.ReplicaSetSpec{")
	s = append(s, "Replicas: "+fmt.Sprintf("%#v", this.Replicas)+",\n")
	s = append(s, "MinReadySeconds: "+fmt.Sprintf("%#v", this.MinReadySeconds)+",\n")
	if this.Selector != nil {
		s = append(s, "Selector: "+fmt.Sprintf("%#v", this.Selector)+",\n")
	}
	if this.Template != nil {
		s = append(s, "Template: "+fmt.Sprintf("%#v", this.Template)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ReplicaSetStatus) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&metadatapb.ReplicaSetStatus{")
	s = append(s, "Replicas: "+fmt.Sprintf("%#v", this.Replicas)+",\n")
	s = append(s, "FullyLabeledReplicas: "+fmt.Sprintf("%#v", this.FullyLabeledReplicas)+",\n")
	s = append(s, "ReadyReplicas: "+fmt.Sprintf("%#v", this.ReadyReplicas)+",\n")
	s = append(s, "AvailableReplicas: "+fmt.Sprintf("%#v", this.AvailableReplicas)+",\n")
	s = append(s, "ObservedGeneration: "+fmt.Sprintf("%#v", this.ObservedGeneration)+",\n")
	if this.Conditions != nil {
		s = append(s, "Conditions: "+fmt.Sprintf("%#v", this.Conditions)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ReplicaSetUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 17)
	s = append(s, "&metadatapb.ReplicaSetUpdate{")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	s = append(s, "Replicas: "+fmt.Sprintf("%#v", this.Replicas)+",\n")
	s = append(s, "FullyLabeledReplicas: "+fmt.Sprintf("%#v", this.FullyLabeledReplicas)+",\n")
	s = append(s, "ReadyReplicas: "+fmt.Sprintf("%#v", this.ReadyReplicas)+",\n")
	s = append(s, "AvailableReplicas: "+fmt.Sprintf("%#v", this.AvailableReplicas)+",\n")
	s = append(s, "ObservedGeneration: "+fmt.Sprintf("%#v", this.ObservedGeneration)+",\n")
	s = append(s, "RequestedReplicas: "+fmt.Sprintf("%#v", this.RequestedReplicas)+",\n")
	if this.Conditions != nil {
		s = append(s, "Conditions: "+fmt.Sprintf("%#v", this.Conditions)+",\n")
	}
	if this.OwnerReferences != nil {
		s = append(s, "OwnerReferences: "+fmt.Sprintf("%#v", this.OwnerReferences)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Deployment) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.Deployment{")
	if this.Metadata != nil {
		s = append(s, "Metadata: "+fmt.Sprintf("%#v", this.Metadata)+",\n")
	}
	if this.Spec != nil {
		s = append(s, "Spec: "+fmt.Sprintf("%#v", this.Spec)+",\n")
	}
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentCondition) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&metadatapb.DeploymentCondition{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	s = append(s, "LastUpdateTimeNS: "+fmt.Sprintf("%#v", this.LastUpdateTimeNS)+",\n")
	s = append(s, "LastTransitionTimeNS: "+fmt.Sprintf("%#v", this.LastTransitionTimeNS)+",\n")
	s = append(s, "Reason: "+fmt.Sprintf("%#v", this.Reason)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentStatus) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&metadatapb.DeploymentStatus{")
	s = append(s, "ObservedGeneration: "+fmt.Sprintf("%#v", this.ObservedGeneration)+",\n")
	s = append(s, "Replicas: "+fmt.Sprintf("%#v", this.Replicas)+",\n")
	s = append(s, "UpdatedReplicas: "+fmt.Sprintf("%#v", this.UpdatedReplicas)+",\n")
	s = append(s, "ReadyReplicas: "+fmt.Sprintf("%#v", this.ReadyReplicas)+",\n")
	s = append(s, "AvailableReplicas: "+fmt.Sprintf("%#v", this.AvailableReplicas)+",\n")
	s = append(s, "UnavailableReplicas: "+fmt.Sprintf("%#v", this.UnavailableReplicas)+",\n")
	if this.Conditions != nil {
		s = append(s, "Conditions: "+fmt.Sprintf("%#v", this.Conditions)+",\n")
	}
	s = append(s, "CollisionCount: "+fmt.Sprintf("%#v", this.CollisionCount)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&metadatapb.DeploymentSpec{")
	s = append(s, "Replicas: "+fmt.Sprintf("%#v", this.Replicas)+",\n")
	if this.Selector != nil {
		s = append(s, "Selector: "+fmt.Sprintf("%#v", this.Selector)+",\n")
	}
	if this.Template != nil {
		s = append(s, "Template: "+fmt.Sprintf("%#v", this.Template)+",\n")
	}
	if this.Strategy != nil {
		s = append(s, "Strategy: "+fmt.Sprintf("%#v", this.Strategy)+",\n")
	}
	s = append(s, "MinReadySeconds: "+fmt.Sprintf("%#v", this.MinReadySeconds)+",\n")
	s = append(s, "RevisionHistoryLimit: "+fmt.Sprintf("%#v", this.RevisionHistoryLimit)+",\n")
	s = append(s, "Paused: "+fmt.Sprintf("%#v", this.Paused)+",\n")
	s = append(s, "ProgressDeadlineSeconds: "+fmt.Sprintf("%#v", this.ProgressDeadlineSeconds)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentStrategy) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.DeploymentStrategy{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	if this.RollingUpdate != nil {
		s = append(s, "RollingUpdate: "+fmt.Sprintf("%#v", this.RollingUpdate)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RollingUpdateDeployment) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&metadatapb.RollingUpdateDeployment{")
	s = append(s, "MaxUnavailable: "+fmt.Sprintf("%#v", this.MaxUnavailable)+",\n")
	s = append(s, "MaxSurge: "+fmt.Sprintf("%#v", this.MaxSurge)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 17)
	s = append(s, "&metadatapb.DeploymentUpdate{")
	s = append(s, "UID: "+fmt.Sprintf("%#v", this.UID)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "StopTimestampNS: "+fmt.Sprintf("%#v", this.StopTimestampNS)+",\n")
	s = append(s, "Namespace: "+fmt.Sprintf("%#v", this.Namespace)+",\n")
	s = append(s, "ObservedGeneration: "+fmt.Sprintf("%#v", this.ObservedGeneration)+",\n")
	s = append(s, "Replicas: "+fmt.Sprintf("%#v", this.Replicas)+",\n")
	s = append(s, "UpdatedReplicas: "+fmt.Sprintf("%#v", this.UpdatedReplicas)+",\n")
	s = append(s, "ReadyReplicas: "+fmt.Sprintf("%#v", this.ReadyReplicas)+",\n")
	s = append(s, "AvailableReplicas: "+fmt.Sprintf("%#v", this.AvailableReplicas)+",\n")
	s = append(s, "UnavailableReplicas: "+fmt.Sprintf("%#v", this.UnavailableReplicas)+",\n")
	s = append(s, "RequestedReplicas: "+fmt.Sprintf("%#v", this.RequestedReplicas)+",\n")
	if this.Conditions != nil {
		s = append(s, "Conditions: "+fmt.Sprintf("%#v", this.Conditions)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ResourceUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&metadatapb.ResourceUpdate{")
	if this.Update != nil {
		s = append(s, "Update: "+fmt.Sprintf("%#v", this.Update)+",\n")
	}
	s = append(s, "UpdateVersion: "+fmt.Sprintf("%#v", this.UpdateVersion)+",\n")
	s = append(s, "PrevUpdateVersion: "+fmt.Sprintf("%#v", this.PrevUpdateVersion)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ResourceUpdate_PodUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.ResourceUpdate_PodUpdate{` +
		`PodUpdate:` + fmt.Sprintf("%#v", this.PodUpdate) + `}`}, ", ")
	return s
}
func (this *ResourceUpdate_ContainerUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.ResourceUpdate_ContainerUpdate{` +
		`ContainerUpdate:` + fmt.Sprintf("%#v", this.ContainerUpdate) + `}`}, ", ")
	return s
}
func (this *ResourceUpdate_ServiceUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.ResourceUpdate_ServiceUpdate{` +
		`ServiceUpdate:` + fmt.Sprintf("%#v", this.ServiceUpdate) + `}`}, ", ")
	return s
}
func (this *ResourceUpdate_NamespaceUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.ResourceUpdate_NamespaceUpdate{` +
		`NamespaceUpdate:` + fmt.Sprintf("%#v", this.NamespaceUpdate) + `}`}, ", ")
	return s
}
func (this *ResourceUpdate_NodeUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.ResourceUpdate_NodeUpdate{` +
		`NodeUpdate:` + fmt.Sprintf("%#v", this.NodeUpdate) + `}`}, ", ")
	return s
}
func (this *ResourceUpdate_ReplicaSetUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.ResourceUpdate_ReplicaSetUpdate{` +
		`ReplicaSetUpdate:` + fmt.Sprintf("%#v", this.ReplicaSetUpdate) + `}`}, ", ")
	return s
}
func (this *ResourceUpdate_DeploymentUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&metadatapb.ResourceUpdate_DeploymentUpdate{` +
		`DeploymentUpdate:` + fmt.Sprintf("%#v", this.DeploymentUpdate) + `}`}, ", ")
	return s
}
func (this *MissingK8SMetadataRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&metadatapb.MissingK8SMetadataRequest{")
	s = append(s, "Selector: "+fmt.Sprintf("%#v", this.Selector)+",\n")
	s = append(s, "FromUpdateVersion: "+fmt.Sprintf("%#v", this.FromUpdateVersion)+",\n")
	s = append(s, "ToUpdateVersion: "+fmt.Sprintf("%#v", this.ToUpdateVersion)+",\n")
	s = append(s, "CustomTopic: "+fmt.Sprintf("%#v", this.CustomTopic)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MissingK8SMetadataResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&metadatapb.MissingK8SMetadataResponse{")
	if this.Updates != nil {
		s = append(s, "Updates: "+fmt.Sprintf("%#v", this.Updates)+",\n")
	}
	s = append(s, "FirstUpdateAvailable: "+fmt.Sprintf("%#v", this.FirstUpdateAvailable)+",\n")
	s = append(s, "LastUpdateAvailable: "+fmt.Sprintf("%#v", this.LastUpdateAvailable)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringMetadata(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *MetadataObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MetadataObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Object != nil {
		{
			size := m.Object.Size()
			i -= size
			if _, err := m.Object.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *MetadataObject_Pod) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataObject_Pod) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Pod != nil {
		{
			size, err := m.Pod.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *MetadataObject_Endpoints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataObject_Endpoints) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Endpoints != nil {
		{
			size, err := m.Endpoints.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *MetadataObject_Service) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataObject_Service) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Service != nil {
		{
			size, err := m.Service.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *MetadataObject_Namespace) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataObject_Namespace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Namespace != nil {
		{
			size, err := m.Namespace.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *MetadataObject_Node) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataObject_Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Node != nil {
		{
			size, err := m.Node.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *MetadataObject_ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataObject_ReplicaSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ReplicaSet != nil {
		{
			size, err := m.ReplicaSet.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *ObjectMetadata) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ObjectMetadata) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ObjectMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Annotations) > 0 {
		for k := range m.Annotations {
			v := m.Annotations[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintMetadata(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintMetadata(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintMetadata(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.OwnerReferences) > 0 {
		for iNdEx := len(m.OwnerReferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OwnerReferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.Labels) > 0 {
		for k := range m.Labels {
			v := m.Labels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintMetadata(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintMetadata(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintMetadata(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.DeletionTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.DeletionTimestampNS))
		i--
		dAtA[i] = 0x30
	}
	if m.CreationTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.CreationTimestampNS))
		i--
		dAtA[i] = 0x28
	}
	if len(m.ResourceVersion) > 0 {
		i -= len(m.ResourceVersion)
		copy(dAtA[i:], m.ResourceVersion)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ResourceVersion)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *OwnerReference) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OwnerReference) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OwnerReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Namespace) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Namespace) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Namespace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Pod) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Pod) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Pod) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Spec != nil {
		{
			size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PodSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PodSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PodSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Priority != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Priority))
		i--
		dAtA[i] = 0x38
	}
	if len(m.PriorityClassName) > 0 {
		i -= len(m.PriorityClassName)
		copy(dAtA[i:], m.PriorityClassName)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.PriorityClassName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Subdomain) > 0 {
		i -= len(m.Subdomain)
		copy(dAtA[i:], m.Subdomain)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Subdomain)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Hostname) > 0 {
		i -= len(m.Hostname)
		copy(dAtA[i:], m.Hostname)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Hostname)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.NodeName) > 0 {
		i -= len(m.NodeName)
		copy(dAtA[i:], m.NodeName)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.NodeName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.NodeSelector) > 0 {
		for k := range m.NodeSelector {
			v := m.NodeSelector[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintMetadata(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintMetadata(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintMetadata(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.DNSPolicy != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.DNSPolicy))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ContainerStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ContainerStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ContainerStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RestartCount != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.RestartCount))
		i--
		dAtA[i] = 0x40
	}
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x32
	}
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x28
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if m.ContainerState != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ContainerState))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ContainerID) > 0 {
		i -= len(m.ContainerID)
		copy(dAtA[i:], m.ContainerID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ContainerID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *K8SEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *K8SEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *K8SEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LastTime != nil {
		{
			size, err := m.LastTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.FirstTime != nil {
		{
			size, err := m.FirstTime.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PodStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PodStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PodStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RestartCount != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.RestartCount))
		i--
		dAtA[i] = 0x68
	}
	if len(m.Events) > 0 {
		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x62
		}
	}
	if m.CreatedAt != nil {
		{
			size, err := m.CreatedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.ContainerStatuses) > 0 {
		for iNdEx := len(m.ContainerStatuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ContainerStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if m.QOSClass != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.QOSClass))
		i--
		dAtA[i] = 0x38
	}
	if len(m.PodIP) > 0 {
		i -= len(m.PodIP)
		copy(dAtA[i:], m.PodIP)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodIP)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.HostIP) > 0 {
		i -= len(m.HostIP)
		copy(dAtA[i:], m.HostIP)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.HostIP)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Phase != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Phase))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *PodCondition) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PodCondition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PodCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if m.Type != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Endpoints) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Endpoints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Endpoints) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Subsets) > 0 {
		for iNdEx := len(m.Subsets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Subsets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EndpointSubset) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EndpointSubset) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EndpointSubset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ports) > 0 {
		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.NotReadyAddresses) > 0 {
		for iNdEx := len(m.NotReadyAddresses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NotReadyAddresses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Addresses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *EndpointAddress) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EndpointAddress) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EndpointAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TargetRef != nil {
		{
			size, err := m.TargetRef.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.NodeName) > 0 {
		i -= len(m.NodeName)
		copy(dAtA[i:], m.NodeName)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.NodeName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Hostname) > 0 {
		i -= len(m.Hostname)
		copy(dAtA[i:], m.Hostname)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Hostname)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.IP) > 0 {
		i -= len(m.IP)
		copy(dAtA[i:], m.IP)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.IP)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EndpointPort) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EndpointPort) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EndpointPort) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Protocol != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Protocol))
		i--
		dAtA[i] = 0x18
	}
	if m.Port != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ObjectReference) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ObjectReference) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ObjectReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ResourceVersion) > 0 {
		i -= len(m.ResourceVersion)
		copy(dAtA[i:], m.ResourceVersion)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ResourceVersion)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Service) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Service) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Service) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Spec != nil {
		{
			size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ServiceSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExternalTrafficPolicy != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ExternalTrafficPolicy))
		i--
		dAtA[i] = 0x38
	}
	if len(m.ExternalName) > 0 {
		i -= len(m.ExternalName)
		copy(dAtA[i:], m.ExternalName)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ExternalName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.LoadBalancerIP) > 0 {
		i -= len(m.LoadBalancerIP)
		copy(dAtA[i:], m.LoadBalancerIP)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.LoadBalancerIP)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ExternalIPs) > 0 {
		for iNdEx := len(m.ExternalIPs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ExternalIPs[iNdEx])
			copy(dAtA[i:], m.ExternalIPs[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.ExternalIPs[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Type != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ClusterIP) > 0 {
		i -= len(m.ClusterIP)
		copy(dAtA[i:], m.ClusterIP)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ClusterIP)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Ports) > 0 {
		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ServicePort) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServicePort) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServicePort) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NodePort != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.NodePort))
		i--
		dAtA[i] = 0x20
	}
	if m.Port != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x18
	}
	if m.Protocol != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Protocol))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ContainerInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ContainerInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ContainerInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Processes) > 0 {
		for iNdEx := len(m.Processes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Processes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.PodUID) > 0 {
		i -= len(m.PodUID)
		copy(dAtA[i:], m.PodUID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodUID)))
		i--
		dAtA[i] = 0x2a
	}
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x18
	}
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ProcessInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ProcessInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProcessInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CID) > 0 {
		i -= len(m.CID)
		copy(dAtA[i:], m.CID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.CID)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.ProcessArgs) > 0 {
		i -= len(m.ProcessArgs)
		copy(dAtA[i:], m.ProcessArgs)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ProcessArgs)))
		i--
		dAtA[i] = 0x32
	}
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x28
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if m.UPID != nil {
		{
			size, err := m.UPID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PodUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PodUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PodUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OwnerReferences) > 0 {
		for iNdEx := len(m.OwnerReferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OwnerReferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.Labels) > 0 {
		i -= len(m.Labels)
		copy(dAtA[i:], m.Labels)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Labels)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x7a
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x72
	}
	if len(m.HostIP) > 0 {
		i -= len(m.HostIP)
		copy(dAtA[i:], m.HostIP)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.HostIP)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.PodIP) > 0 {
		i -= len(m.PodIP)
		copy(dAtA[i:], m.PodIP)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodIP)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.ContainerNames) > 0 {
		for iNdEx := len(m.ContainerNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ContainerNames[iNdEx])
			copy(dAtA[i:], m.ContainerNames[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.ContainerNames[iNdEx])))
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.Hostname) > 0 {
		i -= len(m.Hostname)
		copy(dAtA[i:], m.Hostname)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Hostname)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.NodeName) > 0 {
		i -= len(m.NodeName)
		copy(dAtA[i:], m.NodeName)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.NodeName)))
		i--
		dAtA[i] = 0x4a
	}
	if m.Phase != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Phase))
		i--
		dAtA[i] = 0x40
	}
	if m.QOSClass != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.QOSClass))
		i--
		dAtA[i] = 0x38
	}
	if len(m.ContainerIDs) > 0 {
		for iNdEx := len(m.ContainerIDs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ContainerIDs[iNdEx])
			copy(dAtA[i:], m.ContainerIDs[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.ContainerIDs[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x28
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ContainerUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ContainerUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ContainerUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ContainerType != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ContainerType))
		i--
		dAtA[i] = 0x58
	}
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x4a
	}
	if m.ContainerState != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ContainerState))
		i--
		dAtA[i] = 0x40
	}
	if len(m.PodName) > 0 {
		i -= len(m.PodName)
		copy(dAtA[i:], m.PodName)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodName)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.PodID) > 0 {
		i -= len(m.PodID)
		copy(dAtA[i:], m.PodID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodID)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x2a
	}
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.CID) > 0 {
		i -= len(m.CID)
		copy(dAtA[i:], m.CID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.CID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ServiceUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ServiceUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ServiceUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ClusterIP) > 0 {
		i -= len(m.ClusterIP)
		copy(dAtA[i:], m.ClusterIP)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ClusterIP)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.ExternalIPs) > 0 {
		for iNdEx := len(m.ExternalIPs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ExternalIPs[iNdEx])
			copy(dAtA[i:], m.ExternalIPs[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.ExternalIPs[iNdEx])))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.PodNames) > 0 {
		for iNdEx := len(m.PodNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PodNames[iNdEx])
			copy(dAtA[i:], m.PodNames[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodNames[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.PodIDs) > 0 {
		for iNdEx := len(m.PodIDs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PodIDs[iNdEx])
			copy(dAtA[i:], m.PodIDs[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodIDs[iNdEx])))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x28
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NamespaceUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NamespaceUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NamespaceUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ProcessCreated) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ProcessCreated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProcessCreated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CID) > 0 {
		i -= len(m.CID)
		copy(dAtA[i:], m.CID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.CID)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Cmdline) > 0 {
		i -= len(m.Cmdline)
		copy(dAtA[i:], m.Cmdline)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Cmdline)))
		i--
		dAtA[i] = 0x22
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x18
	}
	if m.UPID != nil {
		{
			size, err := m.UPID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ProcessTerminated) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ProcessTerminated) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProcessTerminated) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x10
	}
	if m.UPID != nil {
		{
			size, err := m.UPID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Node) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Node) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Spec != nil {
		{
			size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NodeSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NodeSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NodeSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PodCIDR) > 0 {
		i -= len(m.PodCIDR)
		copy(dAtA[i:], m.PodCIDR)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodCIDR)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PodCIDRs) > 0 {
		for iNdEx := len(m.PodCIDRs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PodCIDRs[iNdEx])
			copy(dAtA[i:], m.PodCIDRs[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodCIDRs[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *NodeAddress) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NodeAddress) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NodeAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *NodeCondition) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NodeCondition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NodeCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if m.Type != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *NodeStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NodeStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NodeStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Addresses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Phase != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Phase))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *NodeUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NodeUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NodeUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.PodCIDRs) > 0 {
		for iNdEx := len(m.PodCIDRs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PodCIDRs[iNdEx])
			copy(dAtA[i:], m.PodCIDRs[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodCIDRs[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.PodCIDR) > 0 {
		i -= len(m.PodCIDR)
		copy(dAtA[i:], m.PodCIDR)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.PodCIDR)))
		i--
		dAtA[i] = 0x32
	}
	if m.Phase != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Phase))
		i--
		dAtA[i] = 0x28
	}
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ReplicaSet) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReplicaSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Spec != nil {
		{
			size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ReplicaSetCondition) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReplicaSetCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LabelSelectorRequirement) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LabelSelectorRequirement) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LabelSelectorRequirement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Values[iNdEx])
			copy(dAtA[i:], m.Values[iNdEx])
			i = encodeVarintMetadata(dAtA, i, uint64(len(m.Values[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Operator) > 0 {
		i -= len(m.Operator)
		copy(dAtA[i:], m.Operator)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Operator)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LabelSelector) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LabelSelector) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LabelSelector) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MatchExpressions) > 0 {
		for iNdEx := len(m.MatchExpressions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MatchExpressions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.MatchLabels) > 0 {
		for k := range m.MatchLabels {
			v := m.MatchLabels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintMetadata(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintMetadata(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintMetadata(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *PodTemplateSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PodTemplateSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PodTemplateSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Spec != nil {
		{
			size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReplicaSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MinReadySeconds != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.MinReadySeconds))
		i--
		dAtA[i] = 0x20
	}
	if m.Template != nil {
		{
			size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Selector != nil {
		{
			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Replicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Replicas))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReplicaSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.AvailableReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.AvailableReplicas))
		i--
		dAtA[i] = 0x28
	}
	if m.ReadyReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ReadyReplicas))
		i--
		dAtA[i] = 0x20
	}
	if m.ObservedGeneration != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ObservedGeneration))
		i--
		dAtA[i] = 0x18
	}
	if m.FullyLabeledReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.FullyLabeledReplicas))
		i--
		dAtA[i] = 0x10
	}
	if m.Replicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Replicas))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ReplicaSetUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ReplicaSetUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReplicaSetUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RequestedReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.RequestedReplicas))
		i--
		dAtA[i] = 0x68
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.OwnerReferences) > 0 {
		for iNdEx := len(m.OwnerReferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OwnerReferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if m.ObservedGeneration != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ObservedGeneration))
		i--
		dAtA[i] = 0x48
	}
	if m.AvailableReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.AvailableReplicas))
		i--
		dAtA[i] = 0x40
	}
	if m.ReadyReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ReadyReplicas))
		i--
		dAtA[i] = 0x38
	}
	if m.FullyLabeledReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.FullyLabeledReplicas))
		i--
		dAtA[i] = 0x30
	}
	if m.Replicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Replicas))
		i--
		dAtA[i] = 0x28
	}
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Deployment) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Deployment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Deployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Spec != nil {
		{
			size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Metadata != nil {
		{
			size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x2a
	}
	if m.LastTransitionTimeNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.LastTransitionTimeNS))
		i--
		dAtA[i] = 0x20
	}
	if m.LastUpdateTimeNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.LastUpdateTimeNS))
		i--
		dAtA[i] = 0x18
	}
	if m.Status != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if m.Type != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CollisionCount != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.CollisionCount))
		i--
		dAtA[i] = 0x40
	}
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.UnavailableReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.UnavailableReplicas))
		i--
		dAtA[i] = 0x30
	}
	if m.AvailableReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.AvailableReplicas))
		i--
		dAtA[i] = 0x28
	}
	if m.ReadyReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ReadyReplicas))
		i--
		dAtA[i] = 0x20
	}
	if m.UpdatedReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.UpdatedReplicas))
		i--
		dAtA[i] = 0x18
	}
	if m.Replicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Replicas))
		i--
		dAtA[i] = 0x10
	}
	if m.ObservedGeneration != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ObservedGeneration))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ProgressDeadlineSeconds != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ProgressDeadlineSeconds))
		i--
		dAtA[i] = 0x48
	}
	if m.Paused {
		i--
		if m.Paused {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.RevisionHistoryLimit != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.RevisionHistoryLimit))
		i--
		dAtA[i] = 0x30
	}
	if m.MinReadySeconds != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.MinReadySeconds))
		i--
		dAtA[i] = 0x28
	}
	if m.Strategy != nil {
		{
			size, err := m.Strategy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Template != nil {
		{
			size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Selector != nil {
		{
			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Replicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Replicas))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RollingUpdate != nil {
		{
			size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RollingUpdateDeployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MaxSurge) > 0 {
		i -= len(m.MaxSurge)
		copy(dAtA[i:], m.MaxSurge)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.MaxSurge)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.MaxUnavailable) > 0 {
		i -= len(m.MaxUnavailable)
		copy(dAtA[i:], m.MaxUnavailable)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.MaxUnavailable)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeploymentUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DeploymentUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeploymentUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RequestedReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.RequestedReplicas))
		i--
		dAtA[i] = 0x68
	}
	if len(m.Conditions) > 0 {
		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x62
		}
	}
	if m.UnavailableReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.UnavailableReplicas))
		i--
		dAtA[i] = 0x58
	}
	if m.AvailableReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.AvailableReplicas))
		i--
		dAtA[i] = 0x50
	}
	if m.ReadyReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ReadyReplicas))
		i--
		dAtA[i] = 0x48
	}
	if m.UpdatedReplicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.UpdatedReplicas))
		i--
		dAtA[i] = 0x40
	}
	if m.Replicas != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Replicas))
		i--
		dAtA[i] = 0x38
	}
	if m.ObservedGeneration != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ObservedGeneration))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x2a
	}
	if m.StopTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StopTimestampNS))
		i--
		dAtA[i] = 0x20
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.UID) > 0 {
		i -= len(m.UID)
		copy(dAtA[i:], m.UID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ResourceUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ResourceUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Update != nil {
		{
			size := m.Update.Size()
			i -= size
			if _, err := m.Update.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.PrevUpdateVersion != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.PrevUpdateVersion))
		i--
		dAtA[i] = 0x48
	}
	if m.UpdateVersion != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.UpdateVersion))
		i--
		dAtA[i] = 0x40
	}
	return len(dAtA) - i, nil
}

func (m *ResourceUpdate_PodUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceUpdate_PodUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PodUpdate != nil {
		{
			size, err := m.PodUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *ResourceUpdate_ContainerUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceUpdate_ContainerUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ContainerUpdate != nil {
		{
			size, err := m.ContainerUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *ResourceUpdate_ServiceUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceUpdate_ServiceUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ServiceUpdate != nil {
		{
			size, err := m.ServiceUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *ResourceUpdate_NamespaceUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceUpdate_NamespaceUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NamespaceUpdate != nil {
		{
			size, err := m.NamespaceUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *ResourceUpdate_NodeUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceUpdate_NodeUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.NodeUpdate != nil {
		{
			size, err := m.NodeUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *ResourceUpdate_ReplicaSetUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceUpdate_ReplicaSetUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ReplicaSetUpdate != nil {
		{
			size, err := m.ReplicaSetUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *ResourceUpdate_DeploymentUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceUpdate_DeploymentUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DeploymentUpdate != nil {
		{
			size, err := m.DeploymentUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *MissingK8SMetadataRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MissingK8SMetadataRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MissingK8SMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CustomTopic) > 0 {
		i -= len(m.CustomTopic)
		copy(dAtA[i:], m.CustomTopic)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.CustomTopic)))
		i--
		dAtA[i] = 0x22
	}
	if m.FromUpdateVersion != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.FromUpdateVersion))
		i--
		dAtA[i] = 0x18
	}
	if m.ToUpdateVersion != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ToUpdateVersion))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Selector) > 0 {
		i -= len(m.Selector)
		copy(dAtA[i:], m.Selector)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.Selector)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MissingK8SMetadataResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MissingK8SMetadataResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MissingK8SMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LastUpdateAvailable != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.LastUpdateAvailable))
		i--
		dAtA[i] = 0x18
	}
	if m.FirstUpdateAvailable != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.FirstUpdateAvailable))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Updates) > 0 {
		for iNdEx := len(m.Updates) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Updates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintMetadata(dAtA []byte, offset int, v uint64) int {
	offset -= sovMetadata(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MetadataObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Object != nil {
		n += m.Object.Size()
	}
	return n
}

func (m *MetadataObject_Pod) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pod != nil {
		l = m.Pod.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *MetadataObject_Endpoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Endpoints != nil {
		l = m.Endpoints.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *MetadataObject_Service) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Service != nil {
		l = m.Service.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *MetadataObject_Namespace) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Namespace != nil {
		l = m.Namespace.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *MetadataObject_Node) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *MetadataObject_ReplicaSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReplicaSet != nil {
		l = m.ReplicaSet.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *ObjectMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.ResourceVersion)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.CreationTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.CreationTimestampNS))
	}
	if m.DeletionTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.DeletionTimestampNS))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovMetadata(uint64(len(k))) + 1 + len(v) + sovMetadata(uint64(len(v)))
			n += mapEntrySize + 1 + sovMetadata(uint64(mapEntrySize))
		}
	}
	if len(m.OwnerReferences) > 0 {
		for _, e := range m.OwnerReferences {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovMetadata(uint64(len(k))) + 1 + len(v) + sovMetadata(uint64(len(v)))
			n += mapEntrySize + 1 + sovMetadata(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *OwnerReference) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Kind)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *Namespace) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *Pod) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Spec != nil {
		l = m.Spec.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *PodSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DNSPolicy != 0 {
		n += 1 + sovMetadata(uint64(m.DNSPolicy))
	}
	if len(m.NodeSelector) > 0 {
		for k, v := range m.NodeSelector {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovMetadata(uint64(len(k))) + 1 + len(v) + sovMetadata(uint64(len(v)))
			n += mapEntrySize + 1 + sovMetadata(uint64(mapEntrySize))
		}
	}
	l = len(m.NodeName)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Subdomain)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.PriorityClassName)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Priority != 0 {
		n += 1 + sovMetadata(uint64(m.Priority))
	}
	return n
}

func (m *ContainerStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.ContainerID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.ContainerState != 0 {
		n += 1 + sovMetadata(uint64(m.ContainerState))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.RestartCount != 0 {
		n += 1 + sovMetadata(uint64(m.RestartCount))
	}
	return n
}

func (m *K8SEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.FirstTime != nil {
		l = m.FirstTime.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.LastTime != nil {
		l = m.LastTime.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *PodStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Phase != 0 {
		n += 1 + sovMetadata(uint64(m.Phase))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.HostIP)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.PodIP)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.QOSClass != 0 {
		n += 1 + sovMetadata(uint64(m.QOSClass))
	}
	if len(m.ContainerStatuses) > 0 {
		for _, e := range m.ContainerStatuses {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if m.CreatedAt != nil {
		l = m.CreatedAt.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if len(m.Events) > 0 {
		for _, e := range m.Events {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if m.RestartCount != 0 {
		n += 1 + sovMetadata(uint64(m.RestartCount))
	}
	return n
}

func (m *PodCondition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovMetadata(uint64(m.Type))
	}
	if m.Status != 0 {
		n += 1 + sovMetadata(uint64(m.Status))
	}
	return n
}

func (m *Endpoints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if len(m.Subsets) > 0 {
		for _, e := range m.Subsets {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *EndpointSubset) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for _, e := range m.Addresses {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.NotReadyAddresses) > 0 {
		for _, e := range m.NotReadyAddresses {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.Ports) > 0 {
		for _, e := range m.Ports {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *EndpointAddress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.IP)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.NodeName)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.TargetRef != nil {
		l = m.TargetRef.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *EndpointPort) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Port != 0 {
		n += 1 + sovMetadata(uint64(m.Port))
	}
	if m.Protocol != 0 {
		n += 1 + sovMetadata(uint64(m.Protocol))
	}
	return n
}

func (m *ObjectReference) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Kind)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.ResourceVersion)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *Service) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Spec != nil {
		l = m.Spec.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *ServiceSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ports) > 0 {
		for _, e := range m.Ports {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = len(m.ClusterIP)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovMetadata(uint64(m.Type))
	}
	if len(m.ExternalIPs) > 0 {
		for _, s := range m.ExternalIPs {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = len(m.LoadBalancerIP)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.ExternalName)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.ExternalTrafficPolicy != 0 {
		n += 1 + sovMetadata(uint64(m.ExternalTrafficPolicy))
	}
	return n
}

func (m *ServicePort) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Protocol != 0 {
		n += 1 + sovMetadata(uint64(m.Protocol))
	}
	if m.Port != 0 {
		n += 1 + sovMetadata(uint64(m.Port))
	}
	if m.NodePort != 0 {
		n += 1 + sovMetadata(uint64(m.NodePort))
	}
	return n
}

func (m *ContainerInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	l = len(m.PodUID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if len(m.Processes) > 0 {
		for _, e := range m.Processes {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *ProcessInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.UPID != nil {
		l = m.UPID.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	l = len(m.ProcessArgs)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.CID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *PodUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	if len(m.ContainerIDs) > 0 {
		for _, s := range m.ContainerIDs {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if m.QOSClass != 0 {
		n += 1 + sovMetadata(uint64(m.QOSClass))
	}
	if m.Phase != 0 {
		n += 1 + sovMetadata(uint64(m.Phase))
	}
	l = len(m.NodeName)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Hostname)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if len(m.ContainerNames) > 0 {
		for _, s := range m.ContainerNames {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = len(m.PodIP)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.HostIP)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 2 + l + sovMetadata(uint64(l))
		}
	}
	l = len(m.Labels)
	if l > 0 {
		n += 2 + l + sovMetadata(uint64(l))
	}
	if len(m.OwnerReferences) > 0 {
		for _, e := range m.OwnerReferences {
			l = e.Size()
			n += 2 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *ContainerUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.CID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.PodID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.PodName)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.ContainerState != 0 {
		n += 1 + sovMetadata(uint64(m.ContainerState))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.ContainerType != 0 {
		n += 1 + sovMetadata(uint64(m.ContainerType))
	}
	return n
}

func (m *ServiceUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	if len(m.PodIDs) > 0 {
		for _, s := range m.PodIDs {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.PodNames) > 0 {
		for _, s := range m.PodNames {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.ExternalIPs) > 0 {
		for _, s := range m.ExternalIPs {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = len(m.ClusterIP)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *NamespaceUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	return n
}

func (m *ProcessCreated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UPID != nil {
		l = m.UPID.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	l = len(m.Cmdline)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.CID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *ProcessTerminated) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UPID != nil {
		l = m.UPID.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	return n
}

func (m *Node) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Spec != nil {
		l = m.Spec.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *NodeSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PodCIDRs) > 0 {
		for _, s := range m.PodCIDRs {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = len(m.PodCIDR)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *NodeAddress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovMetadata(uint64(m.Type))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *NodeCondition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovMetadata(uint64(m.Type))
	}
	if m.Status != 0 {
		n += 1 + sovMetadata(uint64(m.Status))
	}
	return n
}

func (m *NodeStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Phase != 0 {
		n += 1 + sovMetadata(uint64(m.Phase))
	}
	if len(m.Addresses) > 0 {
		for _, e := range m.Addresses {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *NodeUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	if m.Phase != 0 {
		n += 1 + sovMetadata(uint64(m.Phase))
	}
	l = len(m.PodCIDR)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if len(m.PodCIDRs) > 0 {
		for _, s := range m.PodCIDRs {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *ReplicaSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Spec != nil {
		l = m.Spec.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *ReplicaSetCondition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovMetadata(uint64(m.Status))
	}
	return n
}

func (m *LabelSelectorRequirement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Operator)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if len(m.Values) > 0 {
		for _, s := range m.Values {
			l = len(s)
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *LabelSelector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.MatchLabels) > 0 {
		for k, v := range m.MatchLabels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovMetadata(uint64(len(k))) + 1 + len(v) + sovMetadata(uint64(len(v)))
			n += mapEntrySize + 1 + sovMetadata(uint64(mapEntrySize))
		}
	}
	if len(m.MatchExpressions) > 0 {
		for _, e := range m.MatchExpressions {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *PodTemplateSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Spec != nil {
		l = m.Spec.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *ReplicaSetSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Replicas != 0 {
		n += 1 + sovMetadata(uint64(m.Replicas))
	}
	if m.Selector != nil {
		l = m.Selector.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Template != nil {
		l = m.Template.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.MinReadySeconds != 0 {
		n += 1 + sovMetadata(uint64(m.MinReadySeconds))
	}
	return n
}

func (m *ReplicaSetStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Replicas != 0 {
		n += 1 + sovMetadata(uint64(m.Replicas))
	}
	if m.FullyLabeledReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.FullyLabeledReplicas))
	}
	if m.ObservedGeneration != 0 {
		n += 1 + sovMetadata(uint64(m.ObservedGeneration))
	}
	if m.ReadyReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.ReadyReplicas))
	}
	if m.AvailableReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.AvailableReplicas))
	}
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	return n
}

func (m *ReplicaSetUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	if m.Replicas != 0 {
		n += 1 + sovMetadata(uint64(m.Replicas))
	}
	if m.FullyLabeledReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.FullyLabeledReplicas))
	}
	if m.ReadyReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.ReadyReplicas))
	}
	if m.AvailableReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.AvailableReplicas))
	}
	if m.ObservedGeneration != 0 {
		n += 1 + sovMetadata(uint64(m.ObservedGeneration))
	}
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if len(m.OwnerReferences) > 0 {
		for _, e := range m.OwnerReferences {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.RequestedReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.RequestedReplicas))
	}
	return n
}

func (m *Deployment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Spec != nil {
		l = m.Spec.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *DeploymentCondition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovMetadata(uint64(m.Type))
	}
	if m.Status != 0 {
		n += 1 + sovMetadata(uint64(m.Status))
	}
	if m.LastUpdateTimeNS != 0 {
		n += 1 + sovMetadata(uint64(m.LastUpdateTimeNS))
	}
	if m.LastTransitionTimeNS != 0 {
		n += 1 + sovMetadata(uint64(m.LastTransitionTimeNS))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *DeploymentStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ObservedGeneration != 0 {
		n += 1 + sovMetadata(uint64(m.ObservedGeneration))
	}
	if m.Replicas != 0 {
		n += 1 + sovMetadata(uint64(m.Replicas))
	}
	if m.UpdatedReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.UpdatedReplicas))
	}
	if m.ReadyReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.ReadyReplicas))
	}
	if m.AvailableReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.AvailableReplicas))
	}
	if m.UnavailableReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.UnavailableReplicas))
	}
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if m.CollisionCount != 0 {
		n += 1 + sovMetadata(uint64(m.CollisionCount))
	}
	return n
}

func (m *DeploymentSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Replicas != 0 {
		n += 1 + sovMetadata(uint64(m.Replicas))
	}
	if m.Selector != nil {
		l = m.Selector.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Template != nil {
		l = m.Template.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Strategy != nil {
		l = m.Strategy.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.MinReadySeconds != 0 {
		n += 1 + sovMetadata(uint64(m.MinReadySeconds))
	}
	if m.RevisionHistoryLimit != 0 {
		n += 1 + sovMetadata(uint64(m.RevisionHistoryLimit))
	}
	if m.Paused {
		n += 2
	}
	if m.ProgressDeadlineSeconds != 0 {
		n += 1 + sovMetadata(uint64(m.ProgressDeadlineSeconds))
	}
	return n
}

func (m *DeploymentStrategy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovMetadata(uint64(m.Type))
	}
	if m.RollingUpdate != nil {
		l = m.RollingUpdate.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *RollingUpdateDeployment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MaxUnavailable)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.MaxSurge)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *DeploymentUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StartTimestampNS))
	}
	if m.StopTimestampNS != 0 {
		n += 1 + sovMetadata(uint64(m.StopTimestampNS))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.ObservedGeneration != 0 {
		n += 1 + sovMetadata(uint64(m.ObservedGeneration))
	}
	if m.Replicas != 0 {
		n += 1 + sovMetadata(uint64(m.Replicas))
	}
	if m.UpdatedReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.UpdatedReplicas))
	}
	if m.ReadyReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.ReadyReplicas))
	}
	if m.AvailableReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.AvailableReplicas))
	}
	if m.UnavailableReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.UnavailableReplicas))
	}
	if len(m.Conditions) > 0 {
		for _, e := range m.Conditions {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if m.RequestedReplicas != 0 {
		n += 1 + sovMetadata(uint64(m.RequestedReplicas))
	}
	return n
}

func (m *ResourceUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Update != nil {
		n += m.Update.Size()
	}
	if m.UpdateVersion != 0 {
		n += 1 + sovMetadata(uint64(m.UpdateVersion))
	}
	if m.PrevUpdateVersion != 0 {
		n += 1 + sovMetadata(uint64(m.PrevUpdateVersion))
	}
	return n
}

func (m *ResourceUpdate_PodUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PodUpdate != nil {
		l = m.PodUpdate.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *ResourceUpdate_ContainerUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContainerUpdate != nil {
		l = m.ContainerUpdate.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *ResourceUpdate_ServiceUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServiceUpdate != nil {
		l = m.ServiceUpdate.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *ResourceUpdate_NamespaceUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NamespaceUpdate != nil {
		l = m.NamespaceUpdate.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *ResourceUpdate_NodeUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeUpdate != nil {
		l = m.NodeUpdate.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *ResourceUpdate_ReplicaSetUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReplicaSetUpdate != nil {
		l = m.ReplicaSetUpdate.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *ResourceUpdate_DeploymentUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DeploymentUpdate != nil {
		l = m.DeploymentUpdate.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}
func (m *MissingK8SMetadataRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Selector)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.ToUpdateVersion != 0 {
		n += 1 + sovMetadata(uint64(m.ToUpdateVersion))
	}
	if m.FromUpdateVersion != 0 {
		n += 1 + sovMetadata(uint64(m.FromUpdateVersion))
	}
	l = len(m.CustomTopic)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *MissingK8SMetadataResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Updates) > 0 {
		for _, e := range m.Updates {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	if m.FirstUpdateAvailable != 0 {
		n += 1 + sovMetadata(uint64(m.FirstUpdateAvailable))
	}
	if m.LastUpdateAvailable != 0 {
		n += 1 + sovMetadata(uint64(m.LastUpdateAvailable))
	}
	return n
}

func sovMetadata(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMetadata(x uint64) (n int) {
	return sovMetadata(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *MetadataObject) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataObject{`,
		`Object:` + fmt.Sprintf("%v", this.Object) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetadataObject_Pod) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataObject_Pod{`,
		`Pod:` + strings.Replace(fmt.Sprintf("%v", this.Pod), "Pod", "Pod", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetadataObject_Endpoints) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataObject_Endpoints{`,
		`Endpoints:` + strings.Replace(fmt.Sprintf("%v", this.Endpoints), "Endpoints", "Endpoints", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetadataObject_Service) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataObject_Service{`,
		`Service:` + strings.Replace(fmt.Sprintf("%v", this.Service), "Service", "Service", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetadataObject_Namespace) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataObject_Namespace{`,
		`Namespace:` + strings.Replace(fmt.Sprintf("%v", this.Namespace), "Namespace", "Namespace", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetadataObject_Node) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataObject_Node{`,
		`Node:` + strings.Replace(fmt.Sprintf("%v", this.Node), "Node", "Node", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetadataObject_ReplicaSet) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataObject_ReplicaSet{`,
		`ReplicaSet:` + strings.Replace(fmt.Sprintf("%v", this.ReplicaSet), "ReplicaSet", "ReplicaSet", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ObjectMetadata) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForOwnerReferences := "[]*OwnerReference{"
	for _, f := range this.OwnerReferences {
		repeatedStringForOwnerReferences += strings.Replace(f.String(), "OwnerReference", "OwnerReference", 1) + ","
	}
	repeatedStringForOwnerReferences += "}"
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	keysForAnnotations := make([]string, 0, len(this.Annotations))
	for k, _ := range this.Annotations {
		keysForAnnotations = append(keysForAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
	mapStringForAnnotations := "map[string]string{"
	for _, k := range keysForAnnotations {
		mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
	}
	mapStringForAnnotations += "}"
	s := strings.Join([]string{`&ObjectMetadata{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
		`CreationTimestampNS:` + fmt.Sprintf("%v", this.CreationTimestampNS) + `,`,
		`DeletionTimestampNS:` + fmt.Sprintf("%v", this.DeletionTimestampNS) + `,`,
		`Labels:` + mapStringForLabels + `,`,
		`OwnerReferences:` + repeatedStringForOwnerReferences + `,`,
		`Annotations:` + mapStringForAnnotations + `,`,
		`}`,
	}, "")
	return s
}
func (this *OwnerReference) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OwnerReference{`,
		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Namespace) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Namespace{`,
		`Metadata:` + strings.Replace(this.Metadata.String(), "ObjectMetadata", "ObjectMetadata", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Pod) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Pod{`,
		`Metadata:` + strings.Replace(this.Metadata.String(), "ObjectMetadata", "ObjectMetadata", 1) + `,`,
		`Spec:` + strings.Replace(this.Spec.String(), "PodSpec", "PodSpec", 1) + `,`,
		`Status:` + strings.Replace(this.Status.String(), "PodStatus", "PodStatus", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PodSpec) String() string {
	if this == nil {
		return "nil"
	}
	keysForNodeSelector := make([]string, 0, len(this.NodeSelector))
	for k, _ := range this.NodeSelector {
		keysForNodeSelector = append(keysForNodeSelector, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
	mapStringForNodeSelector := "map[string]string{"
	for _, k := range keysForNodeSelector {
		mapStringForNodeSelector += fmt.Sprintf("%v: %v,", k, this.NodeSelector[k])
	}
	mapStringForNodeSelector += "}"
	s := strings.Join([]string{`&PodSpec{`,
		`DNSPolicy:` + fmt.Sprintf("%v", this.DNSPolicy) + `,`,
		`NodeSelector:` + mapStringForNodeSelector + `,`,
		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
		`Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`,
		`Subdomain:` + fmt.Sprintf("%v", this.Subdomain) + `,`,
		`PriorityClassName:` + fmt.Sprintf("%v", this.PriorityClassName) + `,`,
		`Priority:` + fmt.Sprintf("%v", this.Priority) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ContainerStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ContainerStatus{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ContainerID:` + fmt.Sprintf("%v", this.ContainerID) + `,`,
		`ContainerState:` + fmt.Sprintf("%v", this.ContainerState) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`RestartCount:` + fmt.Sprintf("%v", this.RestartCount) + `,`,
		`}`,
	}, "")
	return s
}
func (this *K8SEvent) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&K8SEvent{`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`FirstTime:` + strings.Replace(fmt.Sprintf("%v", this.FirstTime), "Timestamp", "types.Timestamp", 1) + `,`,
		`LastTime:` + strings.Replace(fmt.Sprintf("%v", this.LastTime), "Timestamp", "types.Timestamp", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PodStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForContainerStatuses := "[]*ContainerStatus{"
	for _, f := range this.ContainerStatuses {
		repeatedStringForContainerStatuses += strings.Replace(f.String(), "ContainerStatus", "ContainerStatus", 1) + ","
	}
	repeatedStringForContainerStatuses += "}"
	repeatedStringForConditions := "[]*PodCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(f.String(), "PodCondition", "PodCondition", 1) + ","
	}
	repeatedStringForConditions += "}"
	repeatedStringForEvents := "[]*K8SEvent{"
	for _, f := range this.Events {
		repeatedStringForEvents += strings.Replace(fmt.Sprintf("%v", f), "K8SEvent", "K8SEvent", 1) + ","
	}
	repeatedStringForEvents += "}"
	s := strings.Join([]string{`&PodStatus{`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`HostIP:` + fmt.Sprintf("%v", this.HostIP) + `,`,
		`PodIP:` + fmt.Sprintf("%v", this.PodIP) + `,`,
		`QOSClass:` + fmt.Sprintf("%v", this.QOSClass) + `,`,
		`ContainerStatuses:` + repeatedStringForContainerStatuses + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`CreatedAt:` + strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`Events:` + repeatedStringForEvents + `,`,
		`RestartCount:` + fmt.Sprintf("%v", this.RestartCount) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PodCondition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PodCondition{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Endpoints) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSubsets := "[]*EndpointSubset{"
	for _, f := range this.Subsets {
		repeatedStringForSubsets += strings.Replace(f.String(), "EndpointSubset", "EndpointSubset", 1) + ","
	}
	repeatedStringForSubsets += "}"
	s := strings.Join([]string{`&Endpoints{`,
		`Metadata:` + strings.Replace(this.Metadata.String(), "ObjectMetadata", "ObjectMetadata", 1) + `,`,
		`Subsets:` + repeatedStringForSubsets + `,`,
		`}`,
	}, "")
	return s
}
func (this *EndpointSubset) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForAddresses := "[]*EndpointAddress{"
	for _, f := range this.Addresses {
		repeatedStringForAddresses += strings.Replace(f.String(), "EndpointAddress", "EndpointAddress", 1) + ","
	}
	repeatedStringForAddresses += "}"
	repeatedStringForNotReadyAddresses := "[]*EndpointAddress{"
	for _, f := range this.NotReadyAddresses {
		repeatedStringForNotReadyAddresses += strings.Replace(f.String(), "EndpointAddress", "EndpointAddress", 1) + ","
	}
	repeatedStringForNotReadyAddresses += "}"
	repeatedStringForPorts := "[]*EndpointPort{"
	for _, f := range this.Ports {
		repeatedStringForPorts += strings.Replace(f.String(), "EndpointPort", "EndpointPort", 1) + ","
	}
	repeatedStringForPorts += "}"
	s := strings.Join([]string{`&EndpointSubset{`,
		`Addresses:` + repeatedStringForAddresses + `,`,
		`NotReadyAddresses:` + repeatedStringForNotReadyAddresses + `,`,
		`Ports:` + repeatedStringForPorts + `,`,
		`}`,
	}, "")
	return s
}
func (this *EndpointAddress) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EndpointAddress{`,
		`IP:` + fmt.Sprintf("%v", this.IP) + `,`,
		`Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`,
		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
		`TargetRef:` + strings.Replace(this.TargetRef.String(), "ObjectReference", "ObjectReference", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EndpointPort) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EndpointPort{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`Protocol:` + fmt.Sprintf("%v", this.Protocol) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ObjectReference) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ObjectReference{`,
		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Service) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Service{`,
		`Metadata:` + strings.Replace(this.Metadata.String(), "ObjectMetadata", "ObjectMetadata", 1) + `,`,
		`Spec:` + strings.Replace(this.Spec.String(), "ServiceSpec", "ServiceSpec", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ServiceSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForPorts := "[]*ServicePort{"
	for _, f := range this.Ports {
		repeatedStringForPorts += strings.Replace(f.String(), "ServicePort", "ServicePort", 1) + ","
	}
	repeatedStringForPorts += "}"
	s := strings.Join([]string{`&ServiceSpec{`,
		`Ports:` + repeatedStringForPorts + `,`,
		`ClusterIP:` + fmt.Sprintf("%v", this.ClusterIP) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`ExternalIPs:` + fmt.Sprintf("%v", this.ExternalIPs) + `,`,
		`LoadBalancerIP:` + fmt.Sprintf("%v", this.LoadBalancerIP) + `,`,
		`ExternalName:` + fmt.Sprintf("%v", this.ExternalName) + `,`,
		`ExternalTrafficPolicy:` + fmt.Sprintf("%v", this.ExternalTrafficPolicy) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ServicePort) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ServicePort{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Protocol:` + fmt.Sprintf("%v", this.Protocol) + `,`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`NodePort:` + fmt.Sprintf("%v", this.NodePort) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ContainerInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForProcesses := "[]*ProcessInfo{"
	for _, f := range this.Processes {
		repeatedStringForProcesses += strings.Replace(f.String(), "ProcessInfo", "ProcessInfo", 1) + ","
	}
	repeatedStringForProcesses += "}"
	s := strings.Join([]string{`&ContainerInfo{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`PodUID:` + fmt.Sprintf("%v", this.PodUID) + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`Processes:` + repeatedStringForProcesses + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProcessInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProcessInfo{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`UPID:` + strings.Replace(fmt.Sprintf("%v", this.UPID), "UInt128", "typespb.UInt128", 1) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`ProcessArgs:` + fmt.Sprintf("%v", this.ProcessArgs) + `,`,
		`CID:` + fmt.Sprintf("%v", this.CID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PodUpdate) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]*PodCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(f.String(), "PodCondition", "PodCondition", 1) + ","
	}
	repeatedStringForConditions += "}"
	repeatedStringForOwnerReferences := "[]*OwnerReference{"
	for _, f := range this.OwnerReferences {
		repeatedStringForOwnerReferences += strings.Replace(f.String(), "OwnerReference", "OwnerReference", 1) + ","
	}
	repeatedStringForOwnerReferences += "}"
	s := strings.Join([]string{`&PodUpdate{`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`ContainerIDs:` + fmt.Sprintf("%v", this.ContainerIDs) + `,`,
		`QOSClass:` + fmt.Sprintf("%v", this.QOSClass) + `,`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
		`Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`,
		`ContainerNames:` + fmt.Sprintf("%v", this.ContainerNames) + `,`,
		`PodIP:` + fmt.Sprintf("%v", this.PodIP) + `,`,
		`HostIP:` + fmt.Sprintf("%v", this.HostIP) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
		`OwnerReferences:` + repeatedStringForOwnerReferences + `,`,
		`}`,
	}, "")
	return s
}
func (this *ContainerUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ContainerUpdate{`,
		`CID:` + fmt.Sprintf("%v", this.CID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`PodID:` + fmt.Sprintf("%v", this.PodID) + `,`,
		`PodName:` + fmt.Sprintf("%v", this.PodName) + `,`,
		`ContainerState:` + fmt.Sprintf("%v", this.ContainerState) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`ContainerType:` + fmt.Sprintf("%v", this.ContainerType) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ServiceUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ServiceUpdate{`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`PodIDs:` + fmt.Sprintf("%v", this.PodIDs) + `,`,
		`PodNames:` + fmt.Sprintf("%v", this.PodNames) + `,`,
		`ExternalIPs:` + fmt.Sprintf("%v", this.ExternalIPs) + `,`,
		`ClusterIP:` + fmt.Sprintf("%v", this.ClusterIP) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NamespaceUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NamespaceUpdate{`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProcessCreated) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProcessCreated{`,
		`UPID:` + strings.Replace(fmt.Sprintf("%v", this.UPID), "UInt128", "typespb.UInt128", 1) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`Cmdline:` + fmt.Sprintf("%v", this.Cmdline) + `,`,
		`CID:` + fmt.Sprintf("%v", this.CID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProcessTerminated) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProcessTerminated{`,
		`UPID:` + strings.Replace(fmt.Sprintf("%v", this.UPID), "UInt128", "typespb.UInt128", 1) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Node) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Node{`,
		`Metadata:` + strings.Replace(this.Metadata.String(), "ObjectMetadata", "ObjectMetadata", 1) + `,`,
		`Spec:` + strings.Replace(this.Spec.String(), "NodeSpec", "NodeSpec", 1) + `,`,
		`Status:` + strings.Replace(this.Status.String(), "NodeStatus", "NodeStatus", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NodeSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NodeSpec{`,
		`PodCIDRs:` + fmt.Sprintf("%v", this.PodCIDRs) + `,`,
		`PodCIDR:` + fmt.Sprintf("%v", this.PodCIDR) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NodeAddress) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NodeAddress{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Address:` + fmt.Sprintf("%v", this.Address) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NodeCondition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NodeCondition{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NodeStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForAddresses := "[]*NodeAddress{"
	for _, f := range this.Addresses {
		repeatedStringForAddresses += strings.Replace(f.String(), "NodeAddress", "NodeAddress", 1) + ","
	}
	repeatedStringForAddresses += "}"
	repeatedStringForConditions := "[]*NodeCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(f.String(), "NodeCondition", "NodeCondition", 1) + ","
	}
	repeatedStringForConditions += "}"
	s := strings.Join([]string{`&NodeStatus{`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Addresses:` + repeatedStringForAddresses + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`}`,
	}, "")
	return s
}
func (this *NodeUpdate) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]*NodeCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(f.String(), "NodeCondition", "NodeCondition", 1) + ","
	}
	repeatedStringForConditions += "}"
	s := strings.Join([]string{`&NodeUpdate{`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`PodCIDR:` + fmt.Sprintf("%v", this.PodCIDR) + `,`,
		`PodCIDRs:` + fmt.Sprintf("%v", this.PodCIDRs) + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`}`,
	}, "")
	return s
}
func (this *ReplicaSet) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ReplicaSet{`,
		`Metadata:` + strings.Replace(this.Metadata.String(), "ObjectMetadata", "ObjectMetadata", 1) + `,`,
		`Spec:` + strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1) + `,`,
		`Status:` + strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ReplicaSetCondition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ReplicaSetCondition{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LabelSelectorRequirement) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LabelSelectorRequirement{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Operator:` + fmt.Sprintf("%v", this.Operator) + `,`,
		`Values:` + fmt.Sprintf("%v", this.Values) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LabelSelector) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMatchExpressions := "[]*LabelSelectorRequirement{"
	for _, f := range this.MatchExpressions {
		repeatedStringForMatchExpressions += strings.Replace(f.String(), "LabelSelectorRequirement", "LabelSelectorRequirement", 1) + ","
	}
	repeatedStringForMatchExpressions += "}"
	keysForMatchLabels := make([]string, 0, len(this.MatchLabels))
	for k, _ := range this.MatchLabels {
		keysForMatchLabels = append(keysForMatchLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels)
	mapStringForMatchLabels := "map[string]string{"
	for _, k := range keysForMatchLabels {
		mapStringForMatchLabels += fmt.Sprintf("%v: %v,", k, this.MatchLabels[k])
	}
	mapStringForMatchLabels += "}"
	s := strings.Join([]string{`&LabelSelector{`,
		`MatchLabels:` + mapStringForMatchLabels + `,`,
		`MatchExpressions:` + repeatedStringForMatchExpressions + `,`,
		`}`,
	}, "")
	return s
}
func (this *PodTemplateSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PodTemplateSpec{`,
		`Metadata:` + strings.Replace(this.Metadata.String(), "ObjectMetadata", "ObjectMetadata", 1) + `,`,
		`Spec:` + strings.Replace(this.Spec.String(), "PodSpec", "PodSpec", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ReplicaSetSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ReplicaSetSpec{`,
		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
		`Selector:` + strings.Replace(this.Selector.String(), "LabelSelector", "LabelSelector", 1) + `,`,
		`Template:` + strings.Replace(this.Template.String(), "PodTemplateSpec", "PodTemplateSpec", 1) + `,`,
		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ReplicaSetStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]*ReplicaSetCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(f.String(), "ReplicaSetCondition", "ReplicaSetCondition", 1) + ","
	}
	repeatedStringForConditions += "}"
	s := strings.Join([]string{`&ReplicaSetStatus{`,
		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
		`FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`}`,
	}, "")
	return s
}
func (this *ReplicaSetUpdate) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]*ReplicaSetCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(f.String(), "ReplicaSetCondition", "ReplicaSetCondition", 1) + ","
	}
	repeatedStringForConditions += "}"
	repeatedStringForOwnerReferences := "[]*OwnerReference{"
	for _, f := range this.OwnerReferences {
		repeatedStringForOwnerReferences += strings.Replace(f.String(), "OwnerReference", "OwnerReference", 1) + ","
	}
	repeatedStringForOwnerReferences += "}"
	s := strings.Join([]string{`&ReplicaSetUpdate{`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
		`FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`,
		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`OwnerReferences:` + repeatedStringForOwnerReferences + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`RequestedReplicas:` + fmt.Sprintf("%v", this.RequestedReplicas) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Deployment) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Deployment{`,
		`Metadata:` + strings.Replace(this.Metadata.String(), "ObjectMetadata", "ObjectMetadata", 1) + `,`,
		`Spec:` + strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1) + `,`,
		`Status:` + strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentCondition) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentCondition{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
		`LastUpdateTimeNS:` + fmt.Sprintf("%v", this.LastUpdateTimeNS) + `,`,
		`LastTransitionTimeNS:` + fmt.Sprintf("%v", this.LastTransitionTimeNS) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]*DeploymentCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(f.String(), "DeploymentCondition", "DeploymentCondition", 1) + ","
	}
	repeatedStringForConditions += "}"
	s := strings.Join([]string{`&DeploymentStatus{`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
		`UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
		`UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`CollisionCount:` + fmt.Sprintf("%v", this.CollisionCount) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentSpec) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentSpec{`,
		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
		`Selector:` + strings.Replace(this.Selector.String(), "LabelSelector", "LabelSelector", 1) + `,`,
		`Template:` + strings.Replace(this.Template.String(), "PodTemplateSpec", "PodTemplateSpec", 1) + `,`,
		`Strategy:` + strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1) + `,`,
		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
		`RevisionHistoryLimit:` + fmt.Sprintf("%v", this.RevisionHistoryLimit) + `,`,
		`Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
		`ProgressDeadlineSeconds:` + fmt.Sprintf("%v", this.ProgressDeadlineSeconds) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentStrategy) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentStrategy{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RollingUpdateDeployment) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RollingUpdateDeployment{`,
		`MaxUnavailable:` + fmt.Sprintf("%v", this.MaxUnavailable) + `,`,
		`MaxSurge:` + fmt.Sprintf("%v", this.MaxSurge) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentUpdate) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConditions := "[]*DeploymentCondition{"
	for _, f := range this.Conditions {
		repeatedStringForConditions += strings.Replace(f.String(), "DeploymentCondition", "DeploymentCondition", 1) + ","
	}
	repeatedStringForConditions += "}"
	s := strings.Join([]string{`&DeploymentUpdate{`,
		`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`StopTimestampNS:` + fmt.Sprintf("%v", this.StopTimestampNS) + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
		`UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
		`UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
		`Conditions:` + repeatedStringForConditions + `,`,
		`RequestedReplicas:` + fmt.Sprintf("%v", this.RequestedReplicas) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceUpdate{`,
		`Update:` + fmt.Sprintf("%v", this.Update) + `,`,
		`UpdateVersion:` + fmt.Sprintf("%v", this.UpdateVersion) + `,`,
		`PrevUpdateVersion:` + fmt.Sprintf("%v", this.PrevUpdateVersion) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceUpdate_PodUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceUpdate_PodUpdate{`,
		`PodUpdate:` + strings.Replace(fmt.Sprintf("%v", this.PodUpdate), "PodUpdate", "PodUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceUpdate_ContainerUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceUpdate_ContainerUpdate{`,
		`ContainerUpdate:` + strings.Replace(fmt.Sprintf("%v", this.ContainerUpdate), "ContainerUpdate", "ContainerUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceUpdate_ServiceUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceUpdate_ServiceUpdate{`,
		`ServiceUpdate:` + strings.Replace(fmt.Sprintf("%v", this.ServiceUpdate), "ServiceUpdate", "ServiceUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceUpdate_NamespaceUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceUpdate_NamespaceUpdate{`,
		`NamespaceUpdate:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceUpdate), "NamespaceUpdate", "NamespaceUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceUpdate_NodeUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceUpdate_NodeUpdate{`,
		`NodeUpdate:` + strings.Replace(fmt.Sprintf("%v", this.NodeUpdate), "NodeUpdate", "NodeUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceUpdate_ReplicaSetUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceUpdate_ReplicaSetUpdate{`,
		`ReplicaSetUpdate:` + strings.Replace(fmt.Sprintf("%v", this.ReplicaSetUpdate), "ReplicaSetUpdate", "ReplicaSetUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResourceUpdate_DeploymentUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResourceUpdate_DeploymentUpdate{`,
		`DeploymentUpdate:` + strings.Replace(fmt.Sprintf("%v", this.DeploymentUpdate), "DeploymentUpdate", "DeploymentUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MissingK8SMetadataRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MissingK8SMetadataRequest{`,
		`Selector:` + fmt.Sprintf("%v", this.Selector) + `,`,
		`ToUpdateVersion:` + fmt.Sprintf("%v", this.ToUpdateVersion) + `,`,
		`FromUpdateVersion:` + fmt.Sprintf("%v", this.FromUpdateVersion) + `,`,
		`CustomTopic:` + fmt.Sprintf("%v", this.CustomTopic) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MissingK8SMetadataResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForUpdates := "[]*ResourceUpdate{"
	for _, f := range this.Updates {
		repeatedStringForUpdates += strings.Replace(f.String(), "ResourceUpdate", "ResourceUpdate", 1) + ","
	}
	repeatedStringForUpdates += "}"
	s := strings.Join([]string{`&MissingK8SMetadataResponse{`,
		`Updates:` + repeatedStringForUpdates + `,`,
		`FirstUpdateAvailable:` + fmt.Sprintf("%v", this.FirstUpdateAvailable) + `,`,
		`LastUpdateAvailable:` + fmt.Sprintf("%v", this.LastUpdateAvailable) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringMetadata(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *MetadataObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MetadataObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetadataObject: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Pod{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Object = &MetadataObject_Pod{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Endpoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Endpoints{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Object = &MetadataObject_Endpoints{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Service{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Object = &MetadataObject_Service{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Namespace{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Object = &MetadataObject_Namespace{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Node{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Object = &MetadataObject_Node{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReplicaSet{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Object = &MetadataObject_ReplicaSet{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ObjectMetadata) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ObjectMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResourceVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreationTimestampNS", wireType)
			}
			m.CreationTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreationTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeletionTimestampNS", wireType)
			}
			m.DeletionTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DeletionTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetadata
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetadata
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthMetadata
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthMetadata
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetadata
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthMetadata
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthMetadata
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipMetadata(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthMetadata
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OwnerReferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OwnerReferences = append(m.OwnerReferences, &OwnerReference{})
			if err := m.OwnerReferences[len(m.OwnerReferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Annotations == nil {
				m.Annotations = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetadata
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetadata
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthMetadata
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthMetadata
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetadata
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthMetadata
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthMetadata
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipMetadata(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthMetadata
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Annotations[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OwnerReference) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OwnerReference: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OwnerReference: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Namespace) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Namespace: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Namespace: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &ObjectMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Pod) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Pod: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Pod: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &ObjectMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Spec == nil {
				m.Spec = &PodSpec{}
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &PodStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PodSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PodSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DNSPolicy", wireType)
			}
			m.DNSPolicy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DNSPolicy |= DNSPolicy(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeSelector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeSelector == nil {
				m.NodeSelector = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetadata
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetadata
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthMetadata
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthMetadata
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetadata
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthMetadata
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthMetadata
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipMetadata(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthMetadata
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NodeSelector[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subdomain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Subdomain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriorityClassName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PriorityClassName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
			}
			m.Priority = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Priority |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContainerStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ContainerStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContainerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerState", wireType)
			}
			m.ContainerState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ContainerState |= ContainerState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestartCount", wireType)
			}
			m.RestartCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RestartCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *K8SEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: K8sEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: K8sEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FirstTime == nil {
				m.FirstTime = &types.Timestamp{}
			}
			if err := m.FirstTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastTime == nil {
				m.LastTime = &types.Timestamp{}
			}
			if err := m.LastTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PodStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PodStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
			}
			m.Phase = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Phase |= PodPhase(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostIP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostIP = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodIP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodIP = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QOSClass", wireType)
			}
			m.QOSClass = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QOSClass |= PodQOSClass(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerStatuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerStatuses = append(m.ContainerStatuses, &ContainerStatus{})
			if err := m.ContainerStatuses[len(m.ContainerStatuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, &PodCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedAt == nil {
				m.CreatedAt = &types.Timestamp{}
			}
			if err := m.CreatedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Events = append(m.Events, &K8SEvent{})
			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestartCount", wireType)
			}
			m.RestartCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RestartCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PodCondition) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PodCondition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodCondition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= PodConditionType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ConditionStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Endpoints) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Endpoints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Endpoints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &ObjectMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subsets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Subsets = append(m.Subsets, &EndpointSubset{})
			if err := m.Subsets[len(m.Subsets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EndpointSubset) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EndpointSubset: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EndpointSubset: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, &EndpointAddress{})
			if err := m.Addresses[len(m.Addresses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotReadyAddresses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NotReadyAddresses = append(m.NotReadyAddresses, &EndpointAddress{})
			if err := m.NotReadyAddresses[len(m.NotReadyAddresses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ports = append(m.Ports, &EndpointPort{})
			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EndpointAddress) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EndpointAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EndpointAddress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IP = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetRef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TargetRef == nil {
				m.TargetRef = &ObjectReference{}
			}
			if err := m.TargetRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EndpointPort) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EndpointPort: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EndpointPort: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
			}
			m.Protocol = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Protocol |= IPProtocol(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ObjectReference) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ObjectReference: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ObjectReference: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResourceVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Service) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Service: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Service: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &ObjectMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Spec == nil {
				m.Spec = &ServiceSpec{}
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ports = append(m.Ports, &ServicePort{})
			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterIP = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= ServiceType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalIPs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExternalIPs = append(m.ExternalIPs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancerIP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoadBalancerIP = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExternalName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalTrafficPolicy", wireType)
			}
			m.ExternalTrafficPolicy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExternalTrafficPolicy |= ExternalTrafficPolicyType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServicePort) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServicePort: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServicePort: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
			}
			m.Protocol = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Protocol |= IPProtocol(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodePort", wireType)
			}
			m.NodePort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodePort |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContainerInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ContainerInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContainerInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodUID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodUID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Processes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Processes = append(m.Processes, &ProcessInfo{})
			if err := m.Processes[len(m.Processes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ProcessInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UPID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UPID == nil {
				m.UPID = &typespb.UInt128{}
			}
			if err := m.UPID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessArgs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessArgs = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PodUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PodUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerIDs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerIDs = append(m.ContainerIDs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QOSClass", wireType)
			}
			m.QOSClass = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QOSClass |= PodQOSClass(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
			}
			m.Phase = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Phase |= PodPhase(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hostname = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerNames", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerNames = append(m.ContainerNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodIP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodIP = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostIP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostIP = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, &PodCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Labels = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OwnerReferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OwnerReferences = append(m.OwnerReferences, &OwnerReference{})
			if err := m.OwnerReferences[len(m.OwnerReferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContainerUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ContainerUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContainerUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerState", wireType)
			}
			m.ContainerState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ContainerState |= ContainerState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerType", wireType)
			}
			m.ContainerType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ContainerType |= ContainerType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ServiceUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ServiceUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ServiceUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodIDs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodIDs = append(m.PodIDs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodNames", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodNames = append(m.PodNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalIPs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExternalIPs = append(m.ExternalIPs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterIP", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterIP = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NamespaceUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NamespaceUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NamespaceUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessCreated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ProcessCreated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessCreated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UPID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UPID == nil {
				m.UPID = &typespb.UInt128{}
			}
			if err := m.UPID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cmdline", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cmdline = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessTerminated) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ProcessTerminated: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessTerminated: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UPID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UPID == nil {
				m.UPID = &typespb.UInt128{}
			}
			if err := m.UPID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Node) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Node: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &ObjectMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Spec == nil {
				m.Spec = &NodeSpec{}
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &NodeStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NodeSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodCIDRs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodCIDRs = append(m.PodCIDRs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodCIDR", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodCIDR = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeAddress) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NodeAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeAddress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= NodeAddressType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeCondition) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NodeCondition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeCondition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= NodeConditionType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ConditionStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NodeStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
			}
			m.Phase = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Phase |= NodePhase(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, &NodeAddress{})
			if err := m.Addresses[len(m.Addresses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, &NodeCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: NodeUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
			}
			m.Phase = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Phase |= NodePhase(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodCIDR", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodCIDR = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodCIDRs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodCIDRs = append(m.PodCIDRs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, &NodeCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &ObjectMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Spec == nil {
				m.Spec = &ReplicaSetSpec{}
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &ReplicaSetStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaSetCondition) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ReplicaSetCondition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ConditionStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LabelSelectorRequirement) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LabelSelectorRequirement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Operator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LabelSelector) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LabelSelector: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MatchLabels == nil {
				m.MatchLabels = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowMetadata
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetadata
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthMetadata
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthMetadata
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowMetadata
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthMetadata
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthMetadata
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipMetadata(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthMetadata
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MatchLabels[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MatchExpressions = append(m.MatchExpressions, &LabelSelectorRequirement{})
			if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PodTemplateSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PodTemplateSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PodTemplateSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &ObjectMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Spec == nil {
				m.Spec = &PodSpec{}
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			m.Replicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Selector == nil {
				m.Selector = &LabelSelector{}
			}
			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Template == nil {
				m.Template = &PodTemplateSpec{}
			}
			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
			}
			m.MinReadySeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinReadySeconds |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			m.Replicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
			}
			m.FullyLabeledReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FullyLabeledReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			m.ObservedGeneration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedGeneration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
			}
			m.ReadyReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadyReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
			}
			m.AvailableReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AvailableReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, &ReplicaSetCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaSetUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ReplicaSetUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaSetUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			m.Replicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
			}
			m.FullyLabeledReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FullyLabeledReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
			}
			m.ReadyReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadyReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
			}
			m.AvailableReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AvailableReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			m.ObservedGeneration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedGeneration |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, &ReplicaSetCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OwnerReferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OwnerReferences = append(m.OwnerReferences, &OwnerReference{})
			if err := m.OwnerReferences[len(m.OwnerReferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestedReplicas", wireType)
			}
			m.RequestedReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestedReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Deployment) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &ObjectMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Spec == nil {
				m.Spec = &DeploymentSpec{}
			}
			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &DeploymentStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentCondition) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= DeploymentConditionType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ConditionStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTimeNS", wireType)
			}
			m.LastUpdateTimeNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastUpdateTimeNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTimeNS", wireType)
			}
			m.LastTransitionTimeNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastTransitionTimeNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			m.ObservedGeneration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedGeneration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			m.Replicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
			}
			m.UpdatedReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
			}
			m.ReadyReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadyReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
			}
			m.AvailableReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AvailableReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
			}
			m.UnavailableReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnavailableReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, &DeploymentCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
			}
			m.CollisionCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CollisionCount |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			m.Replicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Selector == nil {
				m.Selector = &LabelSelector{}
			}
			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Template == nil {
				m.Template = &PodTemplateSpec{}
			}
			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Strategy == nil {
				m.Strategy = &DeploymentStrategy{}
			}
			if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
			}
			m.MinReadySeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinReadySeconds |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
			}
			m.RevisionHistoryLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RevisionHistoryLimit |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Paused = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
			}
			m.ProgressDeadlineSeconds = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProgressDeadlineSeconds |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= DeploymentStrategyType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RollingUpdate == nil {
				m.RollingUpdate = &RollingUpdateDeployment{}
			}
			if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MaxUnavailable = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MaxSurge = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DeploymentUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeploymentUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTimestampNS", wireType)
			}
			m.StopTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StopTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
			}
			m.ObservedGeneration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ObservedGeneration |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
			}
			m.Replicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Replicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
			}
			m.UpdatedReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
			}
			m.ReadyReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadyReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
			}
			m.AvailableReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AvailableReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
			}
			m.UnavailableReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnavailableReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Conditions = append(m.Conditions, &DeploymentCondition{})
			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestedReplicas", wireType)
			}
			m.RequestedReplicas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestedReplicas |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResourceUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ResourceUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResourceUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &PodUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Update = &ResourceUpdate_PodUpdate{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ContainerUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Update = &ResourceUpdate_ContainerUpdate{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ServiceUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Update = &ResourceUpdate_ServiceUpdate{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NamespaceUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Update = &ResourceUpdate_NamespaceUpdate{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NodeUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Update = &ResourceUpdate_NodeUpdate{v}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateVersion", wireType)
			}
			m.UpdateVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdateVersion |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevUpdateVersion", wireType)
			}
			m.PrevUpdateVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PrevUpdateVersion |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaSetUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReplicaSetUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Update = &ResourceUpdate_ReplicaSetUpdate{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeploymentUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DeploymentUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Update = &ResourceUpdate_DeploymentUpdate{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MissingK8SMetadataRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MissingK8sMetadataRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MissingK8sMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Selector = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToUpdateVersion", wireType)
			}
			m.ToUpdateVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ToUpdateVersion |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromUpdateVersion", wireType)
			}
			m.FromUpdateVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FromUpdateVersion |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomTopic", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CustomTopic = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MissingK8SMetadataResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MissingK8sMetadataResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MissingK8sMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Updates = append(m.Updates, &ResourceUpdate{})
			if err := m.Updates[len(m.Updates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstUpdateAvailable", wireType)
			}
			m.FirstUpdateAvailable = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstUpdateAvailable |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateAvailable", wireType)
			}
			m.LastUpdateAvailable = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastUpdateAvailable |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMetadata(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthMetadata
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMetadata
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMetadata
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMetadata        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMetadata          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMetadata = fmt.Errorf("proto: unexpected end of group")
)
